From be7333c8fd15e3291a65a2349165fece7b998cfe Mon Sep 17 00:00:00 2001 From: Alex Chirila Date: Sat, 4 Nov 2017 11:41:30 +0200 Subject: [PATCH 1/7] [BotW] Added experimental shadow blur fix for the AMDShadows pack --- .../ffe0e8c84f6e8da9_000003c000009269_ps.txt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Workaround/BreathOfTheWild_!AMDShadows/ffe0e8c84f6e8da9_000003c000009269_ps.txt b/Workaround/BreathOfTheWild_!AMDShadows/ffe0e8c84f6e8da9_000003c000009269_ps.txt index 38f4ab9b..910ead73 100644 --- a/Workaround/BreathOfTheWild_!AMDShadows/ffe0e8c84f6e8da9_000003c000009269_ps.txt +++ b/Workaround/BreathOfTheWild_!AMDShadows/ffe0e8c84f6e8da9_000003c000009269_ps.txt @@ -374,10 +374,10 @@ R2i.y = floatBitsToInt(intBitsToFloat(0x3da22222) * intBitsToFloat(PS1i)); R2i.z = floatBitsToInt(intBitsToFloat(0x3da22222) * intBitsToFloat(PS1i)); R13i.w = PV1i.y - R127i.x; PV0i.w = R13i.w; -PS0i = floatBitsToInt(uf_blockPS6[53].y); +PS0i = floatBitsToInt(uf_blockPS6[53].y * uf_fragCoordScale.y); PS0i = floatBitsToInt(intBitsToFloat(PS0i) / 2.0); // 3 -R6i.x = floatBitsToInt(uf_blockPS6[53].x); +R6i.x = floatBitsToInt(uf_blockPS6[53].x * uf_fragCoordScale.x); R6i.x = floatBitsToInt(intBitsToFloat(R6i.x) / 2.0); PV1i.y = PV0i.w << 0x00000002; R6i.z = floatBitsToInt(-(intBitsToFloat(PS0i))); @@ -493,7 +493,7 @@ PV0i.y = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(PV1i.w)); R127i.z = floatBitsToInt(mul_nonIEEE(intBitsToFloat(PV1i.y), intBitsToFloat(PS1i))); PV0i.z = R127i.z; // 13 -R7i.x = floatBitsToInt((uf_blockPS6[53].x * 0.5 + intBitsToFloat(PV0i.z))); +R7i.x = floatBitsToInt((uf_blockPS6[53].x * uf_fragCoordScale.x * 0.5 + intBitsToFloat(PV0i.z))); R127i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(0xbb03126f)); R127i.y = clampFI32(R127i.y); PV1i.y = R127i.y; @@ -503,18 +503,18 @@ R8i.x = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R6i.x)); PS1i = R8i.x; // 14 R1i.x = floatBitsToInt(intBitsToFloat(R127i.z) + intBitsToFloat(R126i.w)); -R7i.y = floatBitsToInt((uf_blockPS6[53].y * 0.5 + intBitsToFloat(PV1i.w))); +R7i.y = floatBitsToInt((uf_blockPS6[53].y * uf_fragCoordScale.y * 0.5 + intBitsToFloat(PV1i.w))); R7i.w = PV1i.y; R8i.y = floatBitsToInt(intBitsToFloat(PV1i.w) + intBitsToFloat(R6i.z)); PS0i = R8i.y; // 15 -R9i.x = floatBitsToInt((-(uf_blockPS6[53].x) * 0.5 + intBitsToFloat(R127i.z))); +R9i.x = floatBitsToInt((-(uf_blockPS6[53].x) * uf_fragCoordScale.x * 0.5 + intBitsToFloat(R127i.z))); R1i.y = floatBitsToInt(intBitsToFloat(R127i.w) + intBitsToFloat(R2i.w)); R8i.w = R127i.y; R1i.w = R127i.y; PS1i = R1i.w; // 16 -R9i.y = floatBitsToInt((-(uf_blockPS6[53].y) * 0.5 + intBitsToFloat(R127i.w))); +R9i.y = floatBitsToInt((-(uf_blockPS6[53].y) * uf_fragCoordScale.y * 0.5 + intBitsToFloat(R127i.w))); R9i.w = R127i.y; } if( activeMaskStackC[2] == true ) { From 918d447755607a4f0519a79727b21cef42b0b6f0 Mon Sep 17 00:00:00 2001 From: getdls Date: Sun, 12 Nov 2017 12:34:56 +0100 Subject: [PATCH 2/7] [XCX] Movies, shadows, dof, bloom is now fixed in shaders Add - Fix for stasis move Add - Remove undomment fpr bloom and DOF resolution fixed in shades --- Source/XenobladeX/rules.txt | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-) diff --git a/Source/XenobladeX/rules.txt b/Source/XenobladeX/rules.txt index a6ae7305..88e67a60 100644 --- a/Source/XenobladeX/rules.txt +++ b/Source/XenobladeX/rules.txt @@ -12,6 +12,18 @@ titleIds = 0005000010116100,00050000101C4C00,00050000101C4D00 name = "Xenoblade Chronicles X - " version = 2 +[TextureRedefine] # increase colour depth +formats = 0x01a,0x008 +replaceFormat 0x01f + +[TextureRedefine] # increase colour depth +formats = 0x816 +replaceFormat 0x823 + +[TextureRedefine] # increase colour depth +formats = 0x0810 +replaceFormat 0x81e + [TextureRedefine] # tv width = 1280 height = 720 @@ -22,7 +34,7 @@ overwriteHeight = [TextureRedefine] # half-res alpha width = 640 height = 360 -formatsExcluded = 0x41A # exclude obvious textures +formatsExcluded = 0x41A,0x033,0x031,0x001 #dialog prompt fixes, XCX Logo NLA exclude obvious textures tileModesExcluded = 0x001 overwriteWidth = overwriteHeight = @@ -36,6 +48,7 @@ overwriteHeight = [TextureRedefine] # Gear menu width = 1024 height = 720 +formatsExcluded = 0x001 #in game movies, stasis overwriteWidth = overwriteHeight = @@ -53,22 +66,22 @@ height = 288 overwriteWidth = overwriteHeight = -[TextureRedefine] # "God rays" size (not quality), lens reflections. -width = 256 -height = 144 -overwriteWidth = -overwriteHeight = +#[TextureRedefine] # "God rays" size (not quality), lens reflections. +#width = 256 +#height = 144 +#overwriteWidth = +#overwriteHeight = [TextureRedefine]# Probe glow. Does not increase sample amount, only scales up width = 160 height = 90 -formatsExcluded = 0x816 #fix probe glow -#overwriteWidth = -#overwriteHeight = +#formatsExcluded = 0x816 #fixed in shader +overwriteWidth = +overwriteHeight = [TextureRedefine]# Probe Beacon glow. width = 80 height = 46 -formatsExcluded = 0x816 #fix probe glow -#overwriteWidth = -#overwriteHeight = +#formatsExcluded = 0x816 #fixed in shader +overwriteWidth = +overwriteHeight = From 596e66f7c8c458a307bcfd7453e56a9fcce85a3e Mon Sep 17 00:00:00 2001 From: getdls Date: Sun, 12 Nov 2017 13:32:43 +0100 Subject: [PATCH 3/7] [XCX] Rescale of shadows dof, bloom, motion blur, bias fixes etfc See issue tracker for more details https://github.com/slashiee/cemu_graphic_packs/issues/132 --- .../034f3827969964b2_0000000000000000_vs.txt | 128 ++ .../1bef7019c97eb2b1_0000000000000079_ps.txt | 1311 +++++++++++++++++ .../3cc7e98f78c258b4_00000000000003ca_ps.txt | 78 + .../59df1c7e1806366c_00000000000003c9_ps.txt | 223 +++ .../840947e29015aa9a_00000000000003c9_ps.txt | 167 +++ .../8c1e55fd967b0496_0000000000000079_ps.txt | 167 +++ .../91f557914ed24b44_00000000000003c9_ps.txt | 72 + .../_4d4b09634a7eab30_0000000000001e49_ps.txt | 561 +++++++ .../_59df1c7e1806366c_00000000000003c9_ps.txt | 214 +++ .../_5eb82314ffb8484e_00000000000007f9_ps.txt | 577 ++++++++ .../b253dca415790207_0000000000000079_ps.txt | 140 ++ .../b3fb199c73caa796_00000000000003c9_ps.txt | 215 +++ .../cf4eda5057e1a527_0000000000000000_vs.txt | 67 + .../d8e69e8df8c227f5_00000000000003c9_ps.txt | 182 +++ .../d936195db0dd8e7d_0000000000001e52_ps.txt | 94 ++ .../fdb5a87dd0368c6b_000000000000f249_ps.txt | 479 ++++++ 16 files changed, 4675 insertions(+) create mode 100644 Source/XenobladeX/034f3827969964b2_0000000000000000_vs.txt create mode 100644 Source/XenobladeX/1bef7019c97eb2b1_0000000000000079_ps.txt create mode 100644 Source/XenobladeX/3cc7e98f78c258b4_00000000000003ca_ps.txt create mode 100644 Source/XenobladeX/59df1c7e1806366c_00000000000003c9_ps.txt create mode 100644 Source/XenobladeX/840947e29015aa9a_00000000000003c9_ps.txt create mode 100644 Source/XenobladeX/8c1e55fd967b0496_0000000000000079_ps.txt create mode 100644 Source/XenobladeX/91f557914ed24b44_00000000000003c9_ps.txt create mode 100644 Source/XenobladeX/_4d4b09634a7eab30_0000000000001e49_ps.txt create mode 100644 Source/XenobladeX/_59df1c7e1806366c_00000000000003c9_ps.txt create mode 100644 Source/XenobladeX/_5eb82314ffb8484e_00000000000007f9_ps.txt create mode 100644 Source/XenobladeX/b253dca415790207_0000000000000079_ps.txt create mode 100644 Source/XenobladeX/b3fb199c73caa796_00000000000003c9_ps.txt create mode 100644 Source/XenobladeX/cf4eda5057e1a527_0000000000000000_vs.txt create mode 100644 Source/XenobladeX/d8e69e8df8c227f5_00000000000003c9_ps.txt create mode 100644 Source/XenobladeX/d936195db0dd8e7d_0000000000001e52_ps.txt create mode 100644 Source/XenobladeX/fdb5a87dd0368c6b_000000000000f249_ps.txt 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)); +} From a096202fca32dfdd3bfedfabdb1cee47ae3d5d1e Mon Sep 17 00:00:00 2001 From: getdls Date: Sun, 12 Nov 2017 14:05:46 +0100 Subject: [PATCH 4/7] [XCX] Added cross fade brighness fix Second shader interpolates the grading between inital scene and next.. including fade to black --- .../3cc7e98f78c258b4_00000000000003ca_ps.txt | 11 ++- .../d936195db0dd8e7d_0000000000001e52_ps.txt | 94 +++++++++++++++++++ 2 files changed, 102 insertions(+), 3 deletions(-) create mode 100644 Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt diff --git a/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt b/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt index 4ced3adb..d24f3265 100644 --- a/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt +++ b/Workaround/XenobladeX_AdjustableBrightness/3cc7e98f78c258b4_00000000000003ca_ps.txt @@ -1,7 +1,11 @@ #version 420 #extension GL_ARB_texture_gather : enable -const float bloomFactor = 0.64; // 0.33 recommended for AMD, 0.64 recommended for NVIDIA -// shader 3cc7e98f78c258b4 +// 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 @@ -33,7 +37,7 @@ bool predResult = true; vec3 cubeMapSTM; int cubeMapFaceId; R0f = passParameterSem0; -R0f.xyz = (texture(textureUnitPS0, R0f.xy).xyz * bloomFactor); +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); @@ -69,5 +73,6 @@ PS0f = exp2(R127f.x); 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/Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt b/Workaround/XenobladeX_AdjustableBrightness/d936195db0dd8e7d_0000000000001e52_ps.txt new file mode 100644 index 00000000..3b19a74e --- /dev/null +++ b/Workaround/XenobladeX_AdjustableBrightness/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); +} From b521212b3fb83c51a33f607b9390d3fdee6b2073 Mon Sep 17 00:00:00 2001 From: getdls Date: Mon, 13 Nov 2017 01:21:44 +0100 Subject: [PATCH 5/7] [XCX] 21:9 GUI and 2d elements 21:9 fix for all gui, text, boxes Fix - Floating tower text Fix - Floating waterfall mist Fix - Transport heat wave fx Issue - Minmap missing lef side (suggest disabling in settings) Issue - Loading screens sides issue - Map view is squashed --- .../0b8b33c2f133a514_0000000000000000_vs.txt | 1384 ++++++++++++++++ .../0dbac1e3ebdc5c02_0000000000000000_vs.txt | 1365 ++++++++++++++++ .../1cb8c35cca05b129_0000000000000000_vs.txt | 171 ++ .../1f915b133a255dab_0000000000000000_vs.txt | 207 +++ .../2716141e287247da_0000000000000000_vs.txt | 1299 +++++++++++++++ .../28620f4f4753fb97_0000000000000000_vs.txt | 163 ++ .../3e12e7b9d981b915_0000000000000000_vs.txt | 188 +++ .../46bdcbf27127ae3b_0000000000000000_vs.txt | 132 ++ .../538fc98d957aaa7c_0000000000000000_vs.txt | 188 +++ .../8ff56afdf1a2f837_0000000000000000_vs.txt | 171 ++ .../9bc5e526132c9534_0000000000000000_vs.txt | 138 ++ .../9f390af3897e9112_0000000000000000_vs.txt | 181 +++ .../b679b0945943e505_0000000000000000_vs.txt | 163 ++ .../d6e8f178a5b828f0_0000000000000000_vs.txt | 188 +++ .../d7074f19f5ca3b20_0000000000000000_vs.txt | 290 ++++ .../e082c1f638f8e81e_0000000000000000_vs.txt | 1366 ++++++++++++++++ .../eec2c2cee7a1d42f_0000000000000000_vs.txt | 1395 +++++++++++++++++ Enhancement/XenobladeX_219_GUI/rules.txt | 4 + 18 files changed, 8993 insertions(+) create mode 100644 Enhancement/XenobladeX_219_GUI/0b8b33c2f133a514_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/0dbac1e3ebdc5c02_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/1cb8c35cca05b129_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/1f915b133a255dab_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/2716141e287247da_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/28620f4f4753fb97_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/3e12e7b9d981b915_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/46bdcbf27127ae3b_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/538fc98d957aaa7c_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/8ff56afdf1a2f837_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/9bc5e526132c9534_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/9f390af3897e9112_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/b679b0945943e505_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/d6e8f178a5b828f0_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/d7074f19f5ca3b20_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/e082c1f638f8e81e_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/eec2c2cee7a1d42f_0000000000000000_vs.txt create mode 100644 Enhancement/XenobladeX_219_GUI/rules.txt diff --git a/Enhancement/XenobladeX_219_GUI/0b8b33c2f133a514_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/0b8b33c2f133a514_0000000000000000_vs.txt new file mode 100644 index 00000000..b436029b --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/0b8b33c2f133a514_0000000000000000_vs.txt @@ -0,0 +1,1384 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 0b8b33c2f133a514 +//transport flame 3 *dumped* +uniform ivec4 uf_remappedVS[27]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +layout(location = 3) in uvec4 attrDataSem3; +layout(location = 4) in uvec4 attrDataSem4; +layout(location = 5) in uvec4 attrDataSem5; +layout(location = 6) in uvec4 attrDataSem6; +layout(location = 7) in uvec4 attrDataSem7; +layout(location = 8) in uvec4 attrDataSem8; +layout(location = 9) in uvec4 attrDataSem9; +layout(location = 10) in uvec4 attrDataSem10; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +layout(location = 2) out vec4 passParameterSem2; +layout(location = 3) out vec4 passParameterSem3; +layout(location = 4) out vec4 passParameterSem4; +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 R11i = ivec4(0); +ivec4 R12i = ivec4(0); +ivec4 R13i = ivec4(0); +ivec4 R14i = ivec4(0); +ivec4 R122i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +bool activeMaskStack[5]; +bool activeMaskStackC[6]; +activeMaskStack[0] = false; +activeMaskStack[1] = false; +activeMaskStack[2] = false; +activeMaskStack[3] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStackC[2] = false; +activeMaskStackC[3] = false; +activeMaskStackC[4] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = ivec4(gl_VertexID, 0, 0, gl_InstanceID); +attrDecoder.xy = attrDataSem0.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder = attrDataSem1; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R2i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem4; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R5i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem5; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R6i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xyz = attrDataSem6.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R7i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder.xyz = attrDataSem3.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R4i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder = attrDataSem7; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R8i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem8; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R9i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xy = attrDataSem10.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R11i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xy = attrDataSem9.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R10i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem2.xyzw)/255.0); +R3i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R126i.x = floatBitsToInt(max(intBitsToFloat(R4i.x), -(intBitsToFloat(R4i.x)))); +PV0i.x = R126i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R6i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.y = R123i.y; +R126i.z = floatBitsToInt(max(intBitsToFloat(R4i.y), -(intBitsToFloat(R4i.y)))); +PV0i.z = R126i.z; +R126i.w = R4i.z; +R127i.z = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.z; +// 1 +PV1i.x = floatBitsToInt(fract(intBitsToFloat(PV0i.y))); +R123i.y = floatBitsToInt((intBitsToFloat(R6i.z) * intBitsToFloat(0x3e22f983) + 0.5)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[0].x) + -(0.5)); +R127i.w = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(PV0i.x)); +R127i.x = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(PV0i.z)); +PS1i = R127i.x; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.x = R123i.x; +PV0i.y = floatBitsToInt(fract(intBitsToFloat(R127i.z))); +R127i.z = floatBitsToInt(fract(intBitsToFloat(PV1i.y))); +PV0i.w = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(R126i.w)); +R124i.w = ((intBitsToFloat(PV1i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PS0i = R124i.w; +// 3 +PV1i.x = floatBitsToInt(-(intBitsToFloat(R126i.w)) + intBitsToFloat(PV0i.w)); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R126i.z)) + intBitsToFloat(R127i.x)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R126i.x)) + intBitsToFloat(R127i.w)); +R4i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3e22f983)); +R127i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PS1i = R127i.x; +// 4 +backupReg0i = R127i.z; +backupReg1i = R126i.x; +R126i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R126i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(R124i.w) + intBitsToFloat(R126i.z))); +R127i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +R126i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +R125i.x = R5i.x; +R125i.x = floatBitsToInt(intBitsToFloat(R125i.x) * 2.0); +PS0i = R125i.x; +// 5 +R124i.x = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R7i.y)); +R126i.y = floatBitsToInt(intBitsToFloat(R4i.x) * intBitsToFloat(R7i.x)); +R126i.z = R5i.z; +R126i.z = floatBitsToInt(intBitsToFloat(R126i.z) * 2.0); +R127i.w = R5i.y; +R127i.w = floatBitsToInt(intBitsToFloat(R127i.w) * 2.0); +R125i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(R7i.z)); +PS1i = R125i.w; +// 6 +PV0i.x = R7i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) / 2.0); +R125i.y = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(0x3e22f983)); +PV0i.z = 0; +PV0i.w = R7i.y; +PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) / 2.0); +R124i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(0x3e22f983)); +PS0i = R124i.y; +// 7 +R0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R126i.w)); +R0i.y = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R127i.y)); +R10i.z = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R126i.x)); +R126i.w = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R125i.x)); +R127i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R127i.w)); +PS1i = R127i.x; +// 8 +R126i.x = R5i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R126i.x) * 2.0); +PV0i.y = R5i.z; +PV0i.y = floatBitsToInt(intBitsToFloat(PV0i.y) * 2.0); +PV0i.z = R5i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0); +R127i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R126i.z)); +R125i.x = R5i.w; +R125i.x = floatBitsToInt(intBitsToFloat(R125i.x) * 2.0); +PS0i = R125i.x; +// 9 +backupReg0i = R124i.x; +backupReg1i = R126i.y; +R124i.x = floatBitsToInt(-(intBitsToFloat(R4i.z)) + intBitsToFloat(R125i.w)); +R126i.y = floatBitsToInt(-(intBitsToFloat(R4i.y)) + intBitsToFloat(backupReg0i)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R4i.x)) + intBitsToFloat(backupReg1i)); +R0i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(PV0i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PV0i.y)); +PS1i = R127i.z; +// 10 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +backupReg1i = R0i.y; +backupReg1i = R0i.y; +R0i.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R10i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R10i.z),0.0))); +PV0i.x = R0i.x; +PV0i.y = R0i.x; +PV0i.z = R0i.x; +PV0i.w = R0i.x; +R125i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.x))); +PS0i = R125i.w; +// 11 +backupReg0i = R126i.x; +backupReg1i = R126i.y; +R126i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(backupReg0i)); +R126i.y = floatBitsToInt((intBitsToFloat(R124i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.z))); +R126i.z = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.y))); +R124i.w = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R125i.x)); +R124i.x = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R125i.x)); +PS1i = R124i.x; +// 12 +PV0i.x = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w)); +PV0i.y = floatBitsToInt(intBitsToFloat(R127i.x) + intBitsToFloat(R127i.w)); +R125i.z = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R125i.x)); +R127i.w = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.x)); +R1i.z = 0; +PS0i = R1i.z; +// 13 +R4i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(R7i.x)); +PV1i.x = R4i.x; +R0i.y = floatBitsToInt(intBitsToFloat(R1i.y) * intBitsToFloat(R7i.y)); +PV1i.y = R0i.y; +R0i.z = floatBitsToInt(-(intBitsToFloat(PV0i.x)) + 1.0); +R7i.w = floatBitsToInt(-(intBitsToFloat(PV0i.y)) + 1.0); +R14i.x = 0; +PS1i = R14i.x; +// 14 +R4i.x = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R125i.w)); +R13i.y = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R126i.z)); +R14i.z = floatBitsToInt(intBitsToFloat(R1i.z) + intBitsToFloat(R126i.y)); +R10i.w = floatBitsToInt(intBitsToFloat(R126i.x) + -(intBitsToFloat(R124i.x))); +R12i.y = 0; +PS0i = R12i.y; +// 15 +R12i.x = 0x3f800000; +R7i.y = 0x3f800000; +R12i.z = 0; +R11i.w = floatBitsToInt(intBitsToFloat(R127i.z) + intBitsToFloat(R124i.w)); +R12i.w = floatBitsToInt(intBitsToFloat(R126i.x) + intBitsToFloat(R124i.x)); +PS1i = R12i.w; +// 16 +R1i.z = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(R125i.z)); +R5i.w = floatBitsToInt(intBitsToFloat(R0i.w) + -(intBitsToFloat(R125i.z))); +R13i.w = floatBitsToInt(intBitsToFloat(R127i.z) + -(intBitsToFloat(R124i.w))); +PS0i = R13i.w; +// 17 +R4i.z = floatBitsToInt(-(intBitsToFloat(R127i.w)) + 1.0); +R13i.z = 0; +PS1i = R13i.z; +// 18 +R7i.z = 0; +PS0i = floatBitsToInt(sin((intBitsToFloat(R4i.w))/0.1591549367)); +// 19 +R126i.x = PS0i; +R0i.w = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +PS1i = floatBitsToInt(cos((intBitsToFloat(R4i.w))/0.1591549367)); +// 20 +R127i.w = PS1i; +R1i.w = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +PS0i = R1i.w; +// 21 +PS1i = floatBitsToInt(sin((intBitsToFloat(R125i.y))/0.1591549367)); +// 22 +R6i.y = floatBitsToInt(intBitsToFloat(R126i.x) * intBitsToFloat(PS1i)); +R5i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS1i)); +R2i.w = floatBitsToInt(-(intBitsToFloat(PS1i)) * 1.0); +PS0i = floatBitsToInt(cos((intBitsToFloat(R125i.y))/0.1591549367)); +// 23 +R0i.y = floatBitsToInt(intBitsToFloat(R126i.x) * intBitsToFloat(PS0i)); +R6i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +R4i.w = floatBitsToInt(intBitsToFloat(PS0i) * 1.0); +R127i.w = floatBitsToInt(sin((intBitsToFloat(R124i.y))/0.1591549367)); +PS1i = R127i.w; +// 24 +R6i.x = PS1i; +PS0i = floatBitsToInt(cos((intBitsToFloat(R124i.y))/0.1591549367)); +// 25 +R5i.x = PS0i; +R4i.y = floatBitsToInt(-(intBitsToFloat(R127i.w))); +R5i.y = PS0i; +PS1i = R5i.y; +// 26 +R11i.z = floatBitsToInt(sqrt(intBitsToFloat(R0i.x))); +PS0i = R11i.z; +// 27 +predResult = (intBitsToFloat(0xc0200000) > intBitsToFloat(R6i.w)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.xyz = ivec3(R5i.z,R0i.w,R6i.z); +PV0i.x = R127i.x; +PV0i.y = R127i.y; +PV0i.z = R127i.z; +R127i.w = 0; +R6i.x = uf_remappedVS[1].z; +PS0i = R6i.x; +// 1 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +// 2 +backupReg0i = R127i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +// 3 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.y = uf_remappedVS[4].z; +PS1i = R6i.y; +// 4 +R6i.z = uf_remappedVS[5].z; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV1i.x)); +PS0i = floatBitsToInt(tempResultf); +// 5 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS0i)); +PV1i.x = R126i.x; +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS0i)); +PV1i.y = R127i.y; +// 6 +PV0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * -(intBitsToFloat(PV1i.x))); +PV0i.y = floatBitsToInt(intBitsToFloat(R4i.x) * intBitsToFloat(PV1i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PV1i.y)); +PV0i.w = floatBitsToInt(intBitsToFloat(R4i.x) * -(intBitsToFloat(PV1i.x))); +// 7 +backupReg0i = R127i.y; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.z))); +R123i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.w))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.y))); +PV1i.w = R123i.w; +// 8 +R0i.x = PV1i.z; +PV0i.x = R0i.x; +R0i.y = PV1i.w; +PV0i.y = R0i.y; +R4i.x = PV1i.x; +PS0i = R4i.x; +// 9 +R5i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV1i.x = R5i.x; +PV1i.y = R5i.x; +PV1i.z = R5i.x; +PV1i.w = R5i.x; +R4i.y = R127i.y; +PS1i = R4i.y; +// 10 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.y = tempi.x; +// 11 +backupReg0i = R0i.x; +backupReg1i = R0i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.z = tempi.x; +// 12 +R7i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV0i.x = R7i.x; +PV0i.y = R7i.x; +PV0i.z = R7i.x; +PV0i.w = R7i.x; +// 13 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.y = tempi.x; +// 14 +backupReg0i = R7i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(backupReg0i),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R7i.z = tempi.x; +} +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 +predResult = (0.5 > intBitsToFloat(R6i.w)); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +R7i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R13i.y),intBitsToFloat(R14i.z),0.0))); +PV0i.x = R7i.x; +PV0i.y = R7i.x; +PV0i.z = R7i.x; +PV0i.w = R7i.x; +R0i.x = uf_remappedVS[1].x; +PS0i = R0i.x; +// 1 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R5i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R13i.y),intBitsToFloat(R14i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.y = tempi.x; +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(R12i.z)); +R0i.y = uf_remappedVS[1].y; +R0i.z = uf_remappedVS[1].z; +// 3 +backupReg0i = R4i.y; +R4i.xyz = ivec3(uf_remappedVS[4].x,uf_remappedVS[4].y,uf_remappedVS[4].z); +R122i.x = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(backupReg0i) + intBitsToFloat(PV0i.x))); +PS1i = R122i.x; +// 4 +backupReg0i = R12i.z; +R12i.xyz = ivec3(uf_remappedVS[5].x,uf_remappedVS[5].y,uf_remappedVS[5].z); +PV0i.w = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(backupReg0i)); +R13i.x = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(PS1i))); +PS0i = R13i.x; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(PV0i.w),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R5i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R10i.y = tempi.x; +R1i.z = 0; +PS1i = R1i.z; +// 6 +predResult = (intBitsToFloat(0xbfc00000) > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = uf_remappedVS[1].w; +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].z) * 1.0); +R126i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[4].w))); +// 1 +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[1].y)); +R0i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * 0.0 + intBitsToFloat(PV0i.y))); +PS1i = R0i.z; +// 2 +R0i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.z))); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[1].y)); +// 3 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[4].y)); +R4i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * 0.0 + intBitsToFloat(R127i.z))); +// 4 +R4i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[4].y)); +// 5 +R126i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 6 +R126i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 7 +R0i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.y))); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[5].z) * 1.0); +// 8 +R12i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.y))); +R4i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w))); +R12i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * 0.0 + intBitsToFloat(PV1i.w))); +R12i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R126i.x))); +PS0i = R12i.y; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +activeMaskStack[4] = activeMaskStack[3]; +activeMaskStackC[5] = activeMaskStackC[4]; +// 0 +predResult = (0.0 > intBitsToFloat(R6i.w)); +activeMaskStack[4] = predResult; +activeMaskStackC[5] = predResult == true && activeMaskStackC[4] == true; +} +else { +activeMaskStack[4] = false; +activeMaskStackC[5] = false; +} +if( activeMaskStackC[5] == true ) { +// 0 +R0i.y = 0; +R0i.z = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[5].x))); +R4i.y = 0x3f800000; +PS0i = R4i.y; +// 1 +R12i.y = 0; +R4i.z = 0; +R12i.z = uf_remappedVS[1].x; +PS1i = R12i.z; +// 2 +R10i.z = 0; +// 3 +R13i.z = R11i.z; +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +backupReg0i = R0i.y; +backupReg1i = R0i.z; +backupReg1i = R0i.z; +R5i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),0.0))); +PV0i.x = R5i.x; +PV0i.y = R5i.x; +PV0i.z = R5i.x; +PV0i.w = R5i.x; +R6i.x = backupReg1i; +PS0i = R6i.x; +// 1 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.y = tempi.x; +R6i.y = R4i.z; +PS1i = R6i.y; +// 2 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(R12i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.z = tempi.x; +R6i.z = R12i.z; +PS0i = R6i.z; +// 3 +backupReg0i = R0i.y; +backupReg1i = R0i.z; +R7i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R10i.y),intBitsToFloat(R1i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),0.0))); +PV1i.x = R7i.x; +PV1i.y = R7i.x; +PV1i.z = R7i.x; +PV1i.w = R7i.x; +PS1i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R4i.z)); +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R10i.y),intBitsToFloat(PS1i),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),1.0,0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R7i.y = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R12i.z)); +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R10i.y),intBitsToFloat(PS0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.z = tempi.x; +} +activeMaskStack[2] = activeMaskStack[2] == false; +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +predResult = (1.5 > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R13i.x = R14i.z; +R13i.z = R4i.x; +R7i.x = R7i.z; +PS0i = R7i.x; +// 1 +R7i.y = R1i.y; +R7i.z = R1i.x; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = ((intBitsToFloat(0x40600000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +PV0i.x = R127i.x; +R127i.y = ((intBitsToFloat(0x40200000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +// 1 +R123i.x = ((PV0i.x == 0)?(R13i.y):(R4i.x)); +PV1i.x = R123i.x; +R123i.y = ((PV0i.x == 0)?(R14i.z):(R14i.z)); +PV1i.y = R123i.y; +R123i.z = ((PV0i.x == 0)?(R1i.y):(R1i.x)); +PV1i.z = R123i.z; +R123i.w = ((PV0i.x == 0)?(R4i.x):(R13i.y)); +PV1i.w = R123i.w; +R127i.z = ((PV0i.x == 0)?(R1i.x):(R1i.y)); +PS1i = R127i.z; +// 2 +backupReg0i = R13i.y; +R13i.x = ((R127i.y == 0)?(PV1i.x):(R4i.x)); +R13i.y = ((R127i.y == 0)?(PV1i.w):(R14i.z)); +R13i.z = ((R127i.y == 0)?(PV1i.y):(backupReg0i)); +R123i.w = ((R127i.x == 0)?(R7i.z):(R7i.z)); +PV0i.w = R123i.w; +R7i.x = ((R127i.y == 0)?(PV1i.z):(R1i.x)); +PS0i = R7i.x; +// 3 +backupReg0i = R7i.y; +R12i.x = ((R127i.y == 0)?(0):(R14i.x)); +R7i.y = ((R127i.y == 0)?(R127i.z):(R7i.z)); +R7i.z = ((R127i.y == 0)?(PV0i.w):(R1i.y)); +R12i.y = ((R127i.y == 0)?(0):(backupReg0i)); +PS1i = R12i.y; +// 4 +backupReg0i = R12i.z; +R12i.z = ((R127i.y == 0)?(0x3f800000):(backupReg0i)); +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +backupReg0i = R0i.y; +backupReg0i = R0i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(R6i.x)); +PV0i.y = floatBitsToInt(intBitsToFloat(R6i.z) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R6i.x)); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R5i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(R5i.y)); +PS0i = R127i.z; +// 1 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.w) * 0.0 + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R5i.z) * 1.0); +R125i.z = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R5i.x) + intBitsToFloat(PV0i.z))); +PV1i.z = R125i.z; +R126i.w = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R4i.y) + intBitsToFloat(PV0i.w))); +PV1i.w = R126i.w; +R124i.w = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R6i.x)); +PS1i = R124i.w; +// 2 +R124i.x = floatBitsToInt((intBitsToFloat(R1i.w) * 0.0 + intBitsToFloat(R0i.w))); +R126i.y = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R5i.y)); +R126i.z = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(PV1i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(PV1i.z)); +R126i.x = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(PV1i.x)); +PS0i = R126i.x; +// 3 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R5i.x) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(R4i.w) * 0.0 + intBitsToFloat(R127i.y))); +R124i.z = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R4i.y) + intBitsToFloat(R127i.z))); +R125i.w = floatBitsToInt(intBitsToFloat(R5i.w) * intBitsToFloat(R125i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.w) * intBitsToFloat(R126i.w)); +PS1i = R127i.z; +// 4 +backupReg0i = R126i.x; +backupReg1i = R126i.z; +R126i.x = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg0i))); +PV0i.y = floatBitsToInt(intBitsToFloat(R5i.w) * intBitsToFloat(R125i.x)); +R126i.z = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.w))); +R127i.w = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg1i))); +R10i.z = 0; +PS0i = R10i.z; +// 5 +backupReg0i = R125i.x; +backupReg1i = R127i.z; +R125i.x = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R126i.w)); +R127i.y = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R125i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(backupReg0i)); +R126i.w = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg1i))); +R125i.z = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.y))); +PS1i = R125i.z; +// 6 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R125i.w))); +R124i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.z))); +R126i.z = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i))); +// 7 +backupReg0i = R125i.x; +backupReg1i = R127i.z; +R125i.x = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R127i.w))); +PV1i.y = R126i.y; +R127i.z = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R125i.z; +backupReg1i = R127i.y; +R124i.x = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.x))); +R127i.y = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(PV1i.y)); +R125i.z = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i))); +R123i.w = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +PV0i.w = R123i.w; +PS0i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R126i.z)); +// 9 +backupReg0i = R124i.z; +backupReg1i = R125i.y; +R0i.x = floatBitsToInt((intBitsToFloat(R7i.w) * intBitsToFloat(R127i.x) + intBitsToFloat(PV0i.w))); +R125i.y = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R126i.w))); +R124i.z = floatBitsToInt((intBitsToFloat(R7i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.x))); +R0i.w = floatBitsToInt((intBitsToFloat(R7i.w) * intBitsToFloat(backupReg1i) + intBitsToFloat(R127i.z))); +R122i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R126i.y) + intBitsToFloat(PS0i))); +PS1i = R122i.x; +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R124i.y),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.z = tempi.x; +R127i.w = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R124i.y) + intBitsToFloat(PS1i))); +PS0i = R127i.w; +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R124i.x),intBitsToFloat(R125i.y),intBitsToFloat(R125i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R124i.w = tempi.x; +R126i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].x)); +PS1i = R126i.w; +// 12 +backupReg0i = R127i.z; +R127i.x = floatBitsToInt((intBitsToFloat(R7i.z) * intBitsToFloat(R126i.z) + intBitsToFloat(R127i.y))); +R127i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[6].z)); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].y)); +R125i.w = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[6].x)); +R126i.y = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[6].y)); +PS0i = R126i.y; +// 13 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R124i.z),intBitsToFloat(R0i.w),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +R125i.x = floatBitsToInt((intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R126i.w))); +PS1i = R125i.x; +// 14 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R7i.x) * intBitsToFloat(R124i.y) + intBitsToFloat(backupReg0i))); +PV0i.y = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(R124i.x)); +R123i.z = floatBitsToInt((intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R127i.y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R127i.z))); +PV0i.w = R123i.w; +PS0i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R125i.z)); +// 15 +R5i.x = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R125i.x))); +R5i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.w))); +R5i.z = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.z))); +R123i.w = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PS0i))); +PV1i.w = R123i.w; +R122i.x = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PV0i.y))); +PS1i = R122i.x; +// 16 +backupReg0i = R124i.x; +R124i.x = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(backupReg0i) + intBitsToFloat(PV1i.w))); +PV0i.x = R124i.x; +R125i.y = floatBitsToInt((intBitsToFloat(R7i.z) * intBitsToFloat(R125i.z) + intBitsToFloat(PS1i))); +PV0i.y = R125i.y; +R125i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[6].z)); +PV0i.w = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[6].x)); +PS0i = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[6].y)); +// 17 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R125i.w))); +R124i.y = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV0i.w))); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].z)); +R125i.w = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R126i.y))); +R126i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PS0i))); +PS1i = R126i.x; +// 18 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R124i.z),intBitsToFloat(R0i.w),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.y = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R124i.x) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R125i.z))); +PS0i = R127i.y; +// 19 +backupReg0i = R0i.x; +backupReg1i = R127i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R124i.z),intBitsToFloat(R0i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.z = tempi.x; +R127i.w = floatBitsToInt((intBitsToFloat(R125i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(backupReg1i))); +PS1i = R127i.w; +// 20 +R6i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R127i.x))); +R6i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R125i.w))); +R6i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R127i.y))); +R7i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R124i.y))); +PS0i = R7i.x; +// 21 +R7i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R126i.x))); +R7i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R127i.w))); +// 22 +R13i.z = R11i.z; +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].w) * 1.0); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].z) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].y) * 1.0); +PV0i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].x) * 1.0); +R1i.w = 0; +PS0i = R1i.w; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +R4i.z = R3i.w; +R4i.z = floatBitsToInt(intBitsToFloat(R4i.z) * 2.0); +PS1i = R4i.z; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +R4i.x = ((0.0 >= intBitsToFloat(PS1i))?int(0xFFFFFFFF):int(0x0)); +PS0i = R4i.x; +// 3 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV0i.w))); +PV1i.x = R125i.x; +R125i.y = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.z))); +PV1i.y = R125i.y; +R124i.z = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.y))); +PV1i.z = R124i.z; +R0i.w = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].w) + intBitsToFloat(PV0i.x))); +PV1i.w = R0i.w; +R127i.y = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PS1i = R127i.y; +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.w)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.w = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.w; +// 5 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].y) + -(intBitsToFloat(0x3dcccccd))); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R13i.z)) + intBitsToFloat(uf_remappedVS[11].x)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R10i.z)) + -(intBitsToFloat(PV0i.x))); +PV1i.w = floatBitsToInt(intBitsToFloat(R13i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PS1i = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].w) + -(intBitsToFloat(0x3dcccccd))); +// 6 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + intBitsToFloat(PV1i.y)); +R126i.y = ((intBitsToFloat(PV1i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.z) + -(intBitsToFloat(PV1i.w))); +R126i.w = ((intBitsToFloat(PS1i) >= 0.0)?(floatBitsToInt(1.0)):(0)); +R125i.z = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[12].w)) + 1.0); +PS0i = R125i.z; +// 7 +R0i.x = ((-(1.0) > intBitsToFloat(uf_remappedVS[0].y))?int(0xFFFFFFFF):int(0x0)); +R123i.y = ((intBitsToFloat(PV0i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +PS1i = floatBitsToInt(fract(intBitsToFloat(R127i.w))); +// 8 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(R126i.y)); +R123i.y = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.y = R123i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R126i.w)); +R123i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.w = R123i.w; +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].x) + -(1.0)); +PS0i = R127i.z; +// 9 +R126i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(0x3e22f983)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(PV0i.z)); +R126i.z = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(0x3e22f983)); +PV1i.z = R126i.z; +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].y) + -(1.0)); +R127i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].z) + -(1.0)); +PS1i = R127i.x; +// 10 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.y)) + -(0.0)); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[14].x) + -(intBitsToFloat(uf_remappedVS[14].y))); +R0i.z = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R2i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R126i.y = floatBitsToInt(sin((intBitsToFloat(PV1i.z))/0.1591549367)); +PS0i = R126i.y; +// 11 +R124i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +R2i.y = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R1i.z = ((intBitsToFloat(uf_remappedVS[14].x) == intBitsToFloat(uf_remappedVS[14].y))?int(0xFFFFFFFF):int(0x0)); +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +R127i.x = floatBitsToInt(cos((intBitsToFloat(R126i.z))/0.1591549367)); +PS1i = R127i.x; +// 12 +R11i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PV1i.w)); +PV0i.x = R11i.x; +R124i.y = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(PV1i.w)); +PV0i.y = R124i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(PV1i.w)); +PV0i.z = R127i.z; +R126i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R127i.w = floatBitsToInt(sin((intBitsToFloat(R126i.x))/0.1591549367)); +PS0i = R127i.w; +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(R125i.z)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(R125i.z)); +R126i.z = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(R125i.z)); +R125i.z = floatBitsToInt(cos((intBitsToFloat(R126i.x))/0.1591549367)); +PS1i = R125i.z; +// 14 +R2i.x = floatBitsToInt(intBitsToFloat(R125i.x) + intBitsToFloat(PV1i.y)); +PV0i.x = R2i.x; +R11i.y = floatBitsToInt(intBitsToFloat(R125i.y) + intBitsToFloat(PV1i.x)); +PV0i.y = R11i.y; +R2i.z = floatBitsToInt(intBitsToFloat(R124i.z) + intBitsToFloat(PV1i.w)); +PV0i.z = R2i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R125i.x = floatBitsToInt((-(intBitsToFloat(R126i.y)) * intBitsToFloat(R1i.y) + intBitsToFloat(R126i.w))); +PS0i = R125i.x; +// 15 +backupReg0i = R0i.w; +R12i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)))); +PV1i.x = R12i.x; +PV1i.y = R12i.x; +PV1i.z = R12i.x; +PV1i.w = R12i.x; +R126i.x = floatBitsToInt((-(intBitsToFloat(R127i.w)) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.w))); +PS1i = R126i.x; +// 16 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R11i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R4i.y = tempi.x; +R4i.w = floatBitsToInt(1.0 / intBitsToFloat(R127i.y)); +PS0i = R4i.w; +// 17 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R11i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.z = tempi.x; +R122i.x = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(R124i.x))); +PS1i = R122i.x; +// 18 +backupReg0i = R1i.x; +backupReg1i = R1i.y; +backupReg2i = R126i.z; +backupReg1i = R1i.y; +R1i.x = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(PS1i) + intBitsToFloat(R8i.y))); +R1i.y = floatBitsToInt(intBitsToFloat(backupReg0i) + 0.5); +R126i.z = floatBitsToInt((intBitsToFloat(R125i.z) * intBitsToFloat(backupReg1i) + intBitsToFloat(backupReg2i))); +R127i.w = floatBitsToInt(-(intBitsToFloat(PV1i.x)) * intBitsToFloat(0x42800000)); +R5i.x = floatBitsToInt(-(intBitsToFloat(backupReg1i)) + 0.5); +PS0i = R5i.x; +// 19 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(R11i.x),intBitsToFloat(R124i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.w = floatBitsToInt((intBitsToFloat(R8i.z) * intBitsToFloat(R125i.x) + intBitsToFloat(R8i.x))); +PS1i = R126i.w; +// 20 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R11i.x),intBitsToFloat(R124i.y),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R125i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(0x3a4ccccd)); +PS0i = R125i.w; +// 21 +backupReg0i = R9i.x; +R9i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3ab60b61)); +R8i.y = floatBitsToInt((intBitsToFloat(R9i.z) * intBitsToFloat(R126i.x) + intBitsToFloat(backupReg0i))); +R9i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[12].w)); +PV1i.z = R9i.z; +R8i.w = floatBitsToInt((intBitsToFloat(R9i.w) * intBitsToFloat(R126i.z) + intBitsToFloat(R9i.y))); +R8i.x = floatBitsToInt(intBitsToFloat(R126i.w) + 0.5); +PS1i = R8i.x; +// 22 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R11i.y),intBitsToFloat(R2i.z),intBitsToFloat(R0i.w)),vec4(intBitsToFloat(uf_remappedVS[15].x),intBitsToFloat(uf_remappedVS[15].y),intBitsToFloat(uf_remappedVS[15].z),intBitsToFloat(uf_remappedVS[15].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R9i.w = tempi.x; +R9i.y = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(R125i.w)); +PS0i = R9i.y; +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R11i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[16].x),intBitsToFloat(uf_remappedVS[16].y),intBitsToFloat(uf_remappedVS[16].z),intBitsToFloat(uf_remappedVS[16].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.z = tempi.x; +R126i.x = floatBitsToInt(intBitsToFloat(R9i.z) * intBitsToFloat(R9i.x)); +PS0i = R126i.x; +// 1 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R11i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[17].x),intBitsToFloat(uf_remappedVS[17].y),intBitsToFloat(uf_remappedVS[17].z),intBitsToFloat(uf_remappedVS[17].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.w = floatBitsToInt(intBitsToFloat(R9i.w) + intBitsToFloat(R9i.y)); +PS1i = R127i.w; +// 2 +backupReg0i = R126i.x; +R126i.x = ((R0i.x == 0)?(PS1i):(PS1i)); +R0i.y = floatBitsToInt(intBitsToFloat(R1i.x) + 0.5); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[0].z)); +R126i.w = floatBitsToInt(intBitsToFloat(R126i.z) + intBitsToFloat(backupReg0i)); +R9i.x = floatBitsToInt(intBitsToFloat(R8i.y) + 0.5); +PS0i = R9i.x; +// 3 +backupReg0i = R0i.w; +R124i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R11i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[18].x),intBitsToFloat(uf_remappedVS[18].y),intBitsToFloat(uf_remappedVS[18].z),intBitsToFloat(uf_remappedVS[18].w)))); +PV1i.x = R124i.x; +PV1i.y = R124i.x; +PV1i.z = R124i.x; +PV1i.w = R124i.x; +R125i.x = ((R0i.x == 0)?(PV0i.z):(R1i.w)); +PS1i = R125i.x; +// 4 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +R0i.x = ((R4i.x == 0)?(R126i.x):(0x3f800000)); +R123i.y = ((backupReg0i == 0)?(R126i.w):(R126i.w)); +PV0i.y = R123i.y; +R127i.z = ((intBitsToFloat(uf_remappedVS[14].z) == 0.0)?int(0xFFFFFFFF):int(0x0)); +R123i.w = ((backupReg0i == 0)?(PV1i.x):(PV1i.x)); +PV0i.w = R123i.w; +R9i.y = floatBitsToInt(intBitsToFloat(R8i.w) + 0.5); +PS0i = R9i.y; +// 5 +R127i.x = floatBitsToInt(-(intBitsToFloat(R5i.z))); +R5i.y = ((R4i.x == 0)?(PV0i.y):(0x3f800000)); +R10i.z = ((R4i.x == 0)?(R125i.x):(0x3f800000)); +R0i.w = ((R4i.x == 0)?(PV0i.w):(0x3f800000)); +R1i.x = 0; +PS1i = R1i.x; +// 6 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R8i.y = floatBitsToInt(intBitsToFloat(R11i.y) + -(intBitsToFloat(uf_remappedVS[14].w))); +PS0i = R8i.y; +// 7 +R125i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),0.0))); +PV1i.x = R125i.x; +PV1i.y = R125i.x; +PV1i.z = R125i.x; +PV1i.w = R125i.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +R125i.w = floatBitsToInt(tempResultf); +PS1i = R125i.w; +// 8 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R124i.y = tempi.x; +R126i.x = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(PS1i)); +PS0i = R126i.x; +// 9 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.z = tempi.x; +R127i.y = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(R125i.w)); +PS1i = R127i.y; +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R125i.x),intBitsToFloat(R124i.y),intBitsToFloat(PV1i.x),-0.0),vec4(intBitsToFloat(R125i.x),intBitsToFloat(R124i.y),intBitsToFloat(PV1i.x),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(R125i.w)); +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(R127i.y),intBitsToFloat(PS0i),-0.0),vec4(-(intBitsToFloat(uf_remappedVS[19].x)),-(intBitsToFloat(uf_remappedVS[19].y)),-(intBitsToFloat(uf_remappedVS[19].z)),0.0))); +tempi.x = floatBitsToInt(intBitsToFloat(tempi.x) / 2.0); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 12 +PV0i.x = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(PS1i)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + 0.5); +R2i.z = 0; +PV0i.z = R2i.z; +R1i.w = 0; +PV0i.w = R1i.w; +R6i.x = ((R127i.z == 0)?(R1i.x):(R127i.w)); +PS0i = R6i.x; +// 13 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(max(intBitsToFloat(PV0i.y), 0.0)); +PV1i.x = R127i.x; +R6i.y = ((R127i.z == 0)?(R8i.y):(R126i.w)); +R6i.z = ((R127i.z == 0)?(PV0i.z):(backupReg0i)); +PV1i.w = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +R6i.w = ((R127i.z == 0)?(PV0i.w):(R124i.x)); +PS1i = R6i.w; +// 14 +backupReg0i = R0i.y; +R123i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[20].x) + intBitsToFloat(R2i.w))); +PV0i.x = R123i.x; +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.w) + -(intBitsToFloat(uf_remappedVS[14].y))); +R8i.z = R1i.y; +R123i.w = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[20].y) + intBitsToFloat(R0i.z))); +PV0i.w = R123i.w; +R8i.y = floatBitsToInt(-(intBitsToFloat(backupReg0i)) + 1.0); +PS0i = R8i.y; +// 15 +backupReg0i = R9i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + -(1.0)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(R4i.w)); +R123i.z = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[20].z) + intBitsToFloat(R2i.y))); +PV1i.z = R123i.z; +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.w) + -(1.0)); +R9i.y = floatBitsToInt(-(intBitsToFloat(backupReg0i)) + 1.0); +PS1i = R9i.y; +// 16 +R123i.x = ((R1i.z == 0)?(PV1i.y):(0x3f800000)); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + -(1.0)); +R8i.w = R5i.x; +PS0i = R8i.w; +// 17 +R2i.x = floatBitsToInt(intBitsToFloat(R3i.x) * intBitsToFloat(PV0i.z)); +R2i.y = floatBitsToInt(intBitsToFloat(R3i.y) * intBitsToFloat(PV0i.y)); +R0i.z = PV0i.x; +R0i.z = clampFI32(R0i.z); +R123i.w = floatBitsToInt((intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.w = R123i.w; +R9i.z = floatBitsToInt(intBitsToFloat(R10i.x) * intBitsToFloat(0x3c800000)); +PS1i = R9i.z; +// 18 +R2i.z = floatBitsToInt(intBitsToFloat(R3i.z) * intBitsToFloat(PV1i.w)); +R9i.w = 0x3f800000; +// 19 +predResult = (intBitsToFloat(uf_remappedVS[11].y) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(-(intBitsToFloat(R5i.z)) + -(intBitsToFloat(uf_remappedVS[11].x))); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].x)) + intBitsToFloat(uf_remappedVS[11].y)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R4i.z; +R4i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +predResult = (intBitsToFloat(uf_remappedVS[11].w) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(intBitsToFloat(R5i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].z)) + intBitsToFloat(uf_remappedVS[11].w)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R4i.z; +R4i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = ((0.0 >= intBitsToFloat(uf_remappedVS[0].w))?int(0xFFFFFFFF):int(0x0)); +R127i.y = floatBitsToInt(-(intBitsToFloat(R5i.z)) + -(intBitsToFloat(uf_remappedVS[21].x))); +R2i.w = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(R4i.z)); +PS0i = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R5i.z)); +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.w; +R0i.x = ((PV0i.x == 0)?(backupReg0i):(0x3f800000)); +R0i.y = ((PV0i.x == 0)?(R5i.y):(0x3f800000)); +R0i.z = ((PV0i.x == 0)?(R10i.z):(0x3f800000)); +R0i.w = ((PV0i.x == 0)?(backupReg1i):(0x3f800000)); +R122i.x = floatBitsToInt((intBitsToFloat(R4i.y) * intBitsToFloat(R4i.y) + intBitsToFloat(PS0i))); +PS1i = R122i.x; +// 2 +R123i.z = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R12i.x) + intBitsToFloat(PS1i))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].y)); +// 3 +PV1i.z = floatBitsToInt(max(intBitsToFloat(PV0i.w), 0.0)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.z)); +PS1i = floatBitsToInt(tempResultf); +// 4 +R127i.x = floatBitsToInt(intBitsToFloat(R12i.x) * intBitsToFloat(PS1i)); +PV0i.x = R127i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(PS1i)); +PV0i.y = R126i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(PS1i)); +PV0i.z = R127i.z; +tempResultf = log2(intBitsToFloat(PV1i.z)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +R127i.y = floatBitsToInt(tempResultf); +PS0i = R127i.y; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[22].x),intBitsToFloat(uf_remappedVS[22].y),intBitsToFloat(uf_remappedVS[22].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +// 6 +PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.x), -(intBitsToFloat(PV1i.x)))); +PV0i.y = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].z)); +PS0i = floatBitsToInt(intBitsToFloat(uf_remappedVS[23].z) * intBitsToFloat(R127i.z)); +// 7 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[23].y) * intBitsToFloat(R126i.y) + intBitsToFloat(PS0i))); +PV1i.x = R123i.x; +PV1i.w = floatBitsToInt(-(intBitsToFloat(PV0i.x)) + 1.0); +PS1i = floatBitsToInt(exp2(intBitsToFloat(PV0i.y))); +// 8 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[23].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R123i.x = clampFI32(R123i.x); +PV0i.x = R123i.x; +PV0i.z = floatBitsToInt(min(intBitsToFloat(PS1i), 1.0)); +tempResultf = log2(intBitsToFloat(PV1i.w)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0i = floatBitsToInt(tempResultf); +// 9 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[21].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].w)); +tempResultf = log2(intBitsToFloat(PV0i.x)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1i = floatBitsToInt(tempResultf); +// 10 +PV0i.z = floatBitsToInt(intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[25].w)); +R1i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[19].w)); +R127i.x = floatBitsToInt(exp2(intBitsToFloat(PV1i.y))); +PS0i = R127i.x; +// 11 +R127i.z = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].y) + intBitsToFloat(uf_remappedVS[26].y))); +R127i.w = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].x) + intBitsToFloat(uf_remappedVS[26].x))); +R126i.y = floatBitsToInt(exp2(intBitsToFloat(PV0i.z))); +PS1i = R126i.y; +// 12 +R123i.y = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[24].z) + intBitsToFloat(uf_remappedVS[26].z))); +PV0i.y = R123i.y; +// 13 +R1i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].x) + intBitsToFloat(R127i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].y) + intBitsToFloat(R127i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].z) + intBitsToFloat(PV0i.y))); +} +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R0i.x)*(origRatio / newRatio), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem2 = vec4(intBitsToFloat(R6i.x), intBitsToFloat(R6i.y), intBitsToFloat(R6i.z), intBitsToFloat(R6i.w)); +// export +passParameterSem3 = vec4(intBitsToFloat(R8i.x), intBitsToFloat(R8i.y), intBitsToFloat(R8i.z), intBitsToFloat(R8i.w)); +// export +passParameterSem4 = vec4(intBitsToFloat(R9i.x), intBitsToFloat(R9i.y), intBitsToFloat(R9i.z), intBitsToFloat(R9i.w)); +if( activeMaskStackC[1] == true ) { +// 0 +} +} diff --git a/Enhancement/XenobladeX_219_GUI/0dbac1e3ebdc5c02_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/0dbac1e3ebdc5c02_0000000000000000_vs.txt new file mode 100644 index 00000000..4233e82f --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/0dbac1e3ebdc5c02_0000000000000000_vs.txt @@ -0,0 +1,1365 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 0dbac1e3ebdc5c02 +// float arrow ingame *dumped* +uniform ivec4 uf_remappedVS[27]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +layout(location = 3) in uvec4 attrDataSem3; +layout(location = 4) in uvec4 attrDataSem4; +layout(location = 5) in uvec4 attrDataSem5; +layout(location = 6) in uvec4 attrDataSem6; +layout(location = 7) in uvec4 attrDataSem7; +layout(location = 8) in uvec4 attrDataSem8; +layout(location = 9) in uvec4 attrDataSem9; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +layout(location = 2) out vec4 passParameterSem3; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +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 R11i = ivec4(0); +ivec4 R12i = ivec4(0); +ivec4 R13i = ivec4(0); +ivec4 R122i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +bool activeMaskStack[5]; +bool activeMaskStackC[6]; +activeMaskStack[0] = false; +activeMaskStack[1] = false; +activeMaskStack[2] = false; +activeMaskStack[3] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStackC[2] = false; +activeMaskStackC[3] = false; +activeMaskStackC[4] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = ivec4(gl_VertexID, 0, 0, gl_InstanceID); +attrDecoder.xy = attrDataSem0.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder = attrDataSem1; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R2i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem4; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R5i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem5; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R6i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xyz = attrDataSem6.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R7i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder.xyz = attrDataSem3.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R4i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder = attrDataSem7; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R8i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem8; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R9i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xy = attrDataSem9.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R10i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem2.xyzw)/255.0); +R3i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R125i.x = floatBitsToInt(max(intBitsToFloat(R4i.x), -(intBitsToFloat(R4i.x)))); +PV0i.x = R125i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R6i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.y = R123i.y; +R127i.z = floatBitsToInt(max(intBitsToFloat(R4i.y), -(intBitsToFloat(R4i.y)))); +PV0i.z = R127i.z; +R127i.w = R4i.z; +R127i.y = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 1 +R127i.x = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(PV0i.x)); +R123i.y = floatBitsToInt((intBitsToFloat(R6i.z) * intBitsToFloat(0x3e22f983) + 0.5)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[0].x) + -(0.5)); +PV1i.w = floatBitsToInt(fract(intBitsToFloat(PV0i.y))); +R126i.x = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(PV0i.z)); +PS1i = R126i.x; +// 2 +PV0i.x = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +R127i.y = floatBitsToInt(fract(intBitsToFloat(PV1i.y))); +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(R127i.w)); +R124i.w = ((intBitsToFloat(PV1i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PS0i = R124i.w; +// 3 +PV1i.x = floatBitsToInt(-(intBitsToFloat(R127i.w)) + intBitsToFloat(PV0i.w)); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R127i.z)) + intBitsToFloat(R126i.x)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R125i.x)) + intBitsToFloat(R127i.x)); +R4i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3e22f983)); +R126i.z = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PS1i = R126i.z; +// 4 +backupReg0i = R127i.y; +backupReg1i = R125i.x; +R125i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.z))); +R127i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +R126i.y = R5i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) * 2.0); +PS0i = R126i.y; +// 5 +R127i.x = R5i.z; +R127i.x = floatBitsToInt(intBitsToFloat(R127i.x) * 2.0); +R125i.y = floatBitsToInt(intBitsToFloat(R4i.x) * intBitsToFloat(R7i.x)); +R125i.z = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R7i.y)); +R126i.w = R5i.y; +R126i.w = floatBitsToInt(intBitsToFloat(R126i.w) * 2.0); +R125i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(R7i.z)); +PS1i = R125i.w; +// 6 +PV0i.x = R7i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) / 2.0); +R0i.y = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(0x3e22f983)); +PV0i.z = 0; +PV0i.w = R7i.y; +PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) / 2.0); +R126i.z = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(0x3e22f983)); +PS0i = R126i.z; +// 7 +backupReg0i = R126i.w; +R0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R127i.w)); +R6i.y = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R127i.y)); +R6i.z = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R125i.x)); +R126i.w = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R126i.y)); +R124i.y = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(backupReg0i)); +PS1i = R124i.y; +// 8 +PV0i.x = R5i.y; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * 2.0); +R127i.y = R5i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R127i.y) * 2.0); +PV0i.z = R5i.z; +PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0); +R127i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R127i.x)); +R126i.y = R5i.w; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) * 2.0); +PS0i = R126i.y; +// 9 +backupReg0i = R125i.y; +R127i.x = floatBitsToInt(-(intBitsToFloat(R4i.z)) + intBitsToFloat(R125i.w)); +R125i.y = floatBitsToInt(-(intBitsToFloat(R4i.y)) + intBitsToFloat(R125i.z)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R4i.x)) + intBitsToFloat(backupReg0i)); +R0i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(PV0i.x)); +R125i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PV0i.z)); +PS1i = R125i.x; +// 10 +R124i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R0i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),0.0))); +PV0i.x = R124i.x; +PV0i.y = R124i.x; +PV0i.z = R124i.x; +PV0i.w = R124i.x; +R125i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.x))); +PS0i = R125i.w; +// 11 +backupReg0i = R127i.x; +backupReg1i = R125i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R126i.y)); +PV1i.x = R127i.x; +R125i.y = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.z))); +R125i.z = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.y))); +R124i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R126i.y)); +R4i.y = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w)); +PS1i = R4i.y; +// 12 +R126i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R126i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R127i.y)); +R11i.w = floatBitsToInt(intBitsToFloat(R0i.w) + -(intBitsToFloat(PV1i.x))); +R0i.z = 0; +PS0i = R0i.z; +// 13 +R0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(R7i.x)); +PV1i.x = R0i.x; +R5i.y = floatBitsToInt(intBitsToFloat(R1i.y) * intBitsToFloat(R7i.y)); +PV1i.y = R5i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(R124i.y) + intBitsToFloat(R127i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R124i.y)); +R7i.x = 0; +PS1i = R7i.x; +// 14 +R0i.x = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R125i.w)); +R13i.y = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R125i.z)); +R13i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(R125i.y)); +R12i.w = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + 1.0); +R11i.y = 0; +PS0i = R11i.y; +// 15 +R4i.x = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(R127i.x)); +R7i.y = 0x3f800000; +R11i.z = 0; +R5i.w = floatBitsToInt(intBitsToFloat(R127i.z) + -(intBitsToFloat(R124i.w))); +R7i.w = floatBitsToInt(intBitsToFloat(R125i.x) + intBitsToFloat(R126i.x)); +PS1i = R7i.w; +// 16 +R11i.x = 0x3f800000; +R0i.z = floatBitsToInt(-(intBitsToFloat(R4i.y)) + 1.0); +R10i.w = floatBitsToInt(intBitsToFloat(R127i.z) + intBitsToFloat(R124i.w)); +R13i.w = floatBitsToInt(intBitsToFloat(R125i.x) + -(intBitsToFloat(R126i.x))); +PS0i = R13i.w; +// 17 +R1i.z = floatBitsToInt(-(intBitsToFloat(R127i.w)) + 1.0); +R7i.z = 0; +PS1i = R7i.z; +// 18 +R12i.z = 0; +PS0i = floatBitsToInt(sin((intBitsToFloat(R4i.w))/0.1591549367)); +// 19 +R127i.z = PS0i; +R0i.w = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +PS1i = floatBitsToInt(cos((intBitsToFloat(R4i.w))/0.1591549367)); +// 20 +R127i.w = PS1i; +R1i.w = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +PS0i = R1i.w; +// 21 +PS1i = floatBitsToInt(sin((intBitsToFloat(R0i.y))/0.1591549367)); +// 22 +backupReg0i = R0i.y; +R0i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +R4i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS1i)); +R2i.w = floatBitsToInt(-(intBitsToFloat(PS1i)) * 1.0); +PS0i = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +// 23 +R4i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS0i)); +R5i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +R4i.w = floatBitsToInt(intBitsToFloat(PS0i) * 1.0); +R127i.w = floatBitsToInt(sin((intBitsToFloat(R126i.z))/0.1591549367)); +PS1i = R127i.w; +// 24 +R5i.x = PS1i; +PS0i = floatBitsToInt(cos((intBitsToFloat(R126i.z))/0.1591549367)); +// 25 +R6i.x = PS0i; +R6i.y = floatBitsToInt(-(intBitsToFloat(R127i.w))); +R5i.y = PS0i; +PS1i = R5i.y; +// 26 +R10i.z = floatBitsToInt(sqrt(intBitsToFloat(R124i.x))); +PS0i = R10i.z; +// 27 +predResult = (intBitsToFloat(0xc0200000) > intBitsToFloat(R6i.w)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.xyz = ivec3(R4i.z,R0i.w,R5i.z); +PV0i.x = R127i.x; +PV0i.y = R127i.y; +PV0i.z = R127i.z; +R127i.w = 0; +R11i.x = uf_remappedVS[1].z; +PS0i = R11i.x; +// 1 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +// 2 +backupReg0i = R127i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +// 3 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R11i.y = uf_remappedVS[4].z; +PS1i = R11i.y; +// 4 +R11i.z = uf_remappedVS[5].z; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV1i.x)); +PS0i = floatBitsToInt(tempResultf); +// 5 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS0i)); +PV1i.x = R126i.x; +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS0i)); +PV1i.y = R127i.y; +// 6 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * -(intBitsToFloat(PV1i.x))); +PV0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PV1i.y)); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * -(intBitsToFloat(PV1i.x))); +// 7 +backupReg0i = R127i.y; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.z))); +R123i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.w))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.y))); +PV1i.w = R123i.w; +// 8 +R0i.x = PV1i.z; +PV0i.x = R0i.x; +R0i.y = PV1i.w; +PV0i.y = R0i.y; +R4i.x = PV1i.x; +PS0i = R4i.x; +// 9 +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV1i.x = R13i.x; +PV1i.y = R13i.x; +PV1i.z = R13i.x; +PV1i.w = R13i.x; +R4i.y = R127i.y; +PS1i = R4i.y; +// 10 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R13i.y = tempi.x; +// 11 +backupReg0i = R0i.x; +backupReg1i = R0i.y; +backupReg2i = R13i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(backupReg2i),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.z = tempi.x; +// 12 +R5i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV0i.x = R5i.x; +PV0i.y = R5i.x; +PV0i.z = R5i.x; +PV0i.w = R5i.x; +// 13 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.y = tempi.x; +// 14 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.z = tempi.x; +} +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 +predResult = (0.5 > intBitsToFloat(R6i.w)); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +R7i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),0.0))); +PV0i.x = R7i.x; +PV0i.y = R7i.x; +PV0i.z = R7i.x; +PV0i.w = R7i.x; +R4i.x = uf_remappedVS[1].x; +PS0i = R4i.x; +// 1 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.y = tempi.x; +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R11i.z)); +R4i.y = uf_remappedVS[1].y; +R4i.z = uf_remappedVS[1].z; +// 3 +R0i.xyz = ivec3(uf_remappedVS[4].x,uf_remappedVS[4].y,uf_remappedVS[4].z); +R122i.x = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(R6i.y) + intBitsToFloat(PV0i.x))); +PS1i = R122i.x; +// 4 +backupReg0i = R12i.z; +backupReg1i = R6i.x; +R12i.xyz = ivec3(uf_remappedVS[5].x,uf_remappedVS[5].y,uf_remappedVS[5].z); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R11i.z)); +R6i.x = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(backupReg1i) + intBitsToFloat(PS1i))); +PS0i = R6i.x; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(PV0i.w),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.y = tempi.x; +R1i.z = 0; +PS1i = R1i.z; +// 6 +predResult = (intBitsToFloat(0xbfc00000) > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = uf_remappedVS[1].w; +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].z) * 1.0); +R126i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[4].w))); +// 1 +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[1].y)); +R4i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * 0.0 + intBitsToFloat(PV0i.y))); +PS1i = R4i.z; +// 2 +R4i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.z))); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[1].y)); +// 3 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[4].y)); +R0i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * 0.0 + intBitsToFloat(R127i.z))); +// 4 +R0i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[4].y)); +// 5 +R126i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 6 +R126i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 7 +R4i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.y))); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[5].z) * 1.0); +// 8 +R12i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.y))); +R0i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w))); +R12i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * 0.0 + intBitsToFloat(PV1i.w))); +R12i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R126i.x))); +PS0i = R12i.y; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +activeMaskStack[4] = activeMaskStack[3]; +activeMaskStackC[5] = activeMaskStackC[4]; +// 0 +predResult = (0.0 > intBitsToFloat(R6i.w)); +activeMaskStack[4] = predResult; +activeMaskStackC[5] = predResult == true && activeMaskStackC[4] == true; +} +else { +activeMaskStack[4] = false; +activeMaskStackC[5] = false; +} +if( activeMaskStackC[5] == true ) { +// 0 +R4i.y = 0; +R4i.z = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[5].x))); +R0i.y = 0x3f800000; +PS0i = R0i.y; +// 1 +R12i.y = 0; +R0i.z = 0; +R12i.z = uf_remappedVS[1].x; +PS1i = R12i.z; +// 2 +R6i.z = 0; +// 3 +R7i.z = R10i.z; +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV0i.x = R13i.x; +PV0i.y = R13i.x; +PV0i.z = R13i.x; +PV0i.w = R13i.x; +R11i.x = R4i.z; +PS0i = R11i.x; +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.z; +backupReg1i = R0i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(backupReg1i),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.y = tempi.x; +R11i.y = backupReg1i; +PS1i = R11i.y; +// 2 +backupReg0i = R13i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(backupReg0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(R12i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R13i.z = tempi.x; +R11i.z = R12i.z; +PS0i = R11i.z; +// 3 +backupReg0i = R0i.z; +R5i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R1i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV1i.x = R5i.x; +PV1i.y = R5i.x; +PV1i.z = R5i.x; +PV1i.w = R5i.x; +PS1i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(backupReg0i)); +// 4 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(PS1i),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),1.0,0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.y = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R12i.z)); +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(PS0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.z = tempi.x; +} +activeMaskStack[2] = activeMaskStack[2] == false; +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +predResult = (1.5 > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R13i.x = R13i.z; +R13i.z = R0i.x; +R12i.x = R12i.z; +PS0i = R12i.x; +// 1 +R12i.y = R1i.y; +R12i.z = R1i.x; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = ((intBitsToFloat(0x40600000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +PV0i.x = R127i.x; +R127i.y = ((intBitsToFloat(0x40200000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +// 1 +R123i.x = ((PV0i.x == 0)?(R13i.y):(R0i.x)); +PV1i.x = R123i.x; +R123i.y = ((PV0i.x == 0)?(R13i.z):(R13i.z)); +PV1i.y = R123i.y; +R123i.z = ((PV0i.x == 0)?(R1i.y):(R1i.x)); +PV1i.z = R123i.z; +R123i.w = ((PV0i.x == 0)?(R0i.x):(R13i.y)); +PV1i.w = R123i.w; +R127i.z = ((PV0i.x == 0)?(R1i.x):(R1i.y)); +PS1i = R127i.z; +// 2 +backupReg0i = R13i.y; +R13i.x = ((R127i.y == 0)?(PV1i.x):(R0i.x)); +R13i.y = ((R127i.y == 0)?(PV1i.w):(R13i.z)); +R13i.z = ((R127i.y == 0)?(PV1i.y):(backupReg0i)); +R123i.w = ((R127i.x == 0)?(R12i.z):(R12i.z)); +PV0i.w = R123i.w; +R12i.x = ((R127i.y == 0)?(PV1i.z):(R1i.x)); +PS0i = R12i.x; +// 3 +R11i.x = ((R127i.y == 0)?(0):(R7i.x)); +R12i.y = ((R127i.y == 0)?(R127i.z):(R12i.z)); +R12i.z = ((R127i.y == 0)?(PV0i.w):(R1i.y)); +R11i.y = ((R127i.y == 0)?(0):(R7i.y)); +PS1i = R11i.y; +// 4 +backupReg0i = R11i.z; +R11i.z = ((R127i.y == 0)?(0x3f800000):(backupReg0i)); +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +backupReg0i = R0i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(R5i.x)); +PV0i.y = floatBitsToInt(intBitsToFloat(R5i.z) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R5i.x)); +PV0i.w = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R5i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R5i.y)); +PS0i = R127i.z; +// 1 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.w) * 0.0 + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R4i.z) * 1.0); +R125i.z = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R6i.x) + intBitsToFloat(PV0i.z))); +PV1i.z = R125i.z; +R126i.w = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R6i.y) + intBitsToFloat(PV0i.w))); +PV1i.w = R126i.w; +R125i.w = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R5i.x)); +PS1i = R125i.w; +// 2 +R124i.x = floatBitsToInt((intBitsToFloat(R1i.w) * 0.0 + intBitsToFloat(R0i.w))); +R126i.y = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R5i.y)); +R126i.z = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.z)); +R126i.x = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.x)); +PS0i = R126i.x; +// 3 +backupReg0i = R127i.y; +backupReg1i = R127i.z; +R0i.x = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R6i.x) + intBitsToFloat(R127i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(R4i.w) * 0.0 + intBitsToFloat(backupReg0i))); +R127i.z = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R6i.y) + intBitsToFloat(backupReg1i))); +PV1i.w = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R125i.z)); +PS1i = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R126i.w)); +// 4 +backupReg0i = R126i.z; +R127i.x = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R125i.w) + intBitsToFloat(PV1i.w))); +PV0i.y = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R125i.x)); +R126i.z = floatBitsToInt((intBitsToFloat(R4i.x) * intBitsToFloat(R125i.w) + intBitsToFloat(R127i.w))); +R123i.w = floatBitsToInt((intBitsToFloat(R4i.x) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg0i))); +PV0i.w = R123i.w; +R127i.w = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R126i.y) + intBitsToFloat(PS1i))); +PS0i = R127i.w; +// 5 +backupReg0i = R126i.x; +backupReg1i = R0i.z; +R126i.x = floatBitsToInt(intBitsToFloat(R7i.w) * intBitsToFloat(R125i.z)); +R123i.y = floatBitsToInt((intBitsToFloat(R4i.x) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg0i))); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(R7i.w) * intBitsToFloat(R126i.w)); +R126i.w = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.y))); +R125i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R127i.z) + intBitsToFloat(PV0i.w))); +PS1i = R125i.y; +// 6 +backupReg0i = R126i.y; +R5i.x = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(R126i.z))); +R126i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R127i.y) + intBitsToFloat(PV1i.y))); +PV0i.y = R126i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(R7i.w) * intBitsToFloat(R125i.x)); +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(PV1i.z))); +PV0i.w = R123i.w; +R6i.z = 0; +PS0i = R6i.z; +// 7 +backupReg0i = R125i.w; +backupReg1i = R126i.x; +R126i.x = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.z))); +R0i.y = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R127i.z) + intBitsToFloat(PV0i.w))); +R126i.z = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(PV0i.y)); +R125i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(backupReg1i))); +PS1i = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(PV0i.y)); +// 8 +R6i.x = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(R127i.x))); +R124i.y = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R127i.z) + intBitsToFloat(R127i.w))); +R127i.z = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R127i.y) + intBitsToFloat(R126i.w))); +R4i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PS1i))); +PS0i = R4i.x; +// 9 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R125i.y),intBitsToFloat(R126i.y),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.x = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.w))); +PS1i = R7i.x; +// 10 +backupReg0i = R127i.y; +backupReg1i = R126i.x; +backupReg2i = R126i.z; +R126i.x = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[6].y)); +R127i.y = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[6].z)); +R126i.z = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(backupReg1i))); +R125i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[6].x)); +R0i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg2i))); +PS0i = R0i.x; +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R124i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.w = tempi.x; +R127i.x = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(R127i.z)); +PS1i = R127i.x; +// 12 +backupReg0i = R0i.y; +R125i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R7i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R126i.z),0.0))); +PV0i.x = R125i.x; +PV0i.y = R125i.x; +PV0i.z = R125i.x; +PV0i.w = R125i.x; +R124i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R125i.w))); +PS0i = R124i.x; +// 13 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(R124i.y) + intBitsToFloat(backupReg0i))); +PV1i.y = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R126i.z)); +R123i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R127i.y))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R126i.x))); +PV1i.w = R123i.w; +PS1i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R127i.z)); +// 14 +R13i.x = floatBitsToInt((intBitsToFloat(R125i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R124i.x))); +R13i.y = floatBitsToInt((intBitsToFloat(R125i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV1i.w))); +R13i.z = floatBitsToInt((intBitsToFloat(R125i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV1i.z))); +R126i.w = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R0i.y) + intBitsToFloat(PV1i.y))); +R125i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R124i.y) + intBitsToFloat(PS1i))); +PS0i = R125i.x; +// 15 +PV1i.x = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(R126i.z)); +R123i.w = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(R4i.x))); +PV1i.w = R123i.w; +// 16 +R123i.x = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(R0i.x))); +PV0i.x = R123i.x; +R124i.y = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[6].y)); +R126i.z = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[6].z)); +R127i.w = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[6].x)); +R124i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(R0i.y) + intBitsToFloat(PV1i.x))); +PS0i = R124i.x; +// 17 +R123i.x = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(R6i.x) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].x)); +R127i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].z)); +R125i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].y)); +// 18 +backupReg0i = R125i.x; +R125i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R126i.z))); +R123i.y = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R6i.x) + intBitsToFloat(backupReg0i))); +PV0i.y = R123i.y; +R126i.z = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R127i.w))); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R124i.y))); +// 19 +backupReg0i = R124i.x; +backupReg1i = R127i.z; +R124i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R127i.y))); +R123i.y = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(R7i.x) + intBitsToFloat(backupReg0i))); +PV1i.y = R123i.y; +R127i.z = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R125i.w))); +R125i.w = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(backupReg1i))); +// 20 +R11i.x = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R126i.z))); +R11i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R127i.w))); +R123i.z = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R7i.x) + intBitsToFloat(R126i.w))); +PV0i.z = R123i.z; +R11i.z = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R125i.x))); +PS0i = R11i.z; +// 21 +R5i.x = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R124i.x))); +R5i.y = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R127i.z))); +R5i.z = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R125i.w))); +// 22 +R7i.z = R10i.z; +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].w) * 1.0); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].x) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].z) * 1.0); +PV0i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].y) * 1.0); +R1i.w = 0; +PS0i = R1i.w; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].x) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].y) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +R10i.z = R3i.w; +R10i.z = floatBitsToInt(intBitsToFloat(R10i.z) * 2.0); +PS1i = R10i.z; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +R4i.x = ((0.0 >= intBitsToFloat(PS1i))?int(0xFFFFFFFF):int(0x0)); +PS0i = R4i.x; +// 3 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R124i.y = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.w))); +PV1i.y = R124i.y; +R126i.z = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R126i.z; +R0i.w = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].w) + intBitsToFloat(PV0i.x))); +PV1i.w = R0i.w; +R127i.w = floatBitsToInt((intBitsToFloat(R10i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS1i = R127i.w; +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.w)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R10i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 5 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].y) + -(intBitsToFloat(0x3dcccccd))); +PV1i.y = floatBitsToInt(intBitsToFloat(R7i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R7i.z)) + intBitsToFloat(uf_remappedVS[11].x)); +PV1i.w = floatBitsToInt(-(intBitsToFloat(R6i.z)) + -(intBitsToFloat(PV0i.x))); +PS1i = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].w) + -(intBitsToFloat(0x3dcccccd))); +// 6 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.w)) + intBitsToFloat(PV1i.z)); +R126i.y = ((intBitsToFloat(PS1i) >= 0.0)?(floatBitsToInt(1.0)):(0)); +R127i.z = ((intBitsToFloat(PV1i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.w) + -(intBitsToFloat(PV1i.y))); +R125i.y = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[12].w)) + 1.0); +PS0i = R125i.y; +// 7 +R0i.x = ((-(1.0) > intBitsToFloat(uf_remappedVS[0].y))?int(0xFFFFFFFF):int(0x0)); +R123i.y = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.y = R123i.y; +R123i.z = ((intBitsToFloat(PV0i.w) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.z = R123i.z; +PV1i.w = floatBitsToInt(fract(intBitsToFloat(R127i.w))); +PS1i = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +// 8 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R127i.z)); +R123i.y = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(R126i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].x) + -(1.0)); +PS0i = R127i.z; +// 9 +R126i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(0x3e22f983)); +PV1i.x = R126i.x; +R126i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3e22f983)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(PV0i.w)); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].y) + -(1.0)); +R127i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].z) + -(1.0)); +PS1i = R127i.x; +// 10 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + -(0.0)); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[14].x) + -(intBitsToFloat(uf_remappedVS[14].y))); +R0i.z = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R2i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R127i.w = floatBitsToInt(sin((intBitsToFloat(PV1i.x))/0.1591549367)); +PS0i = R127i.w; +// 11 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +R0i.y = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R4i.z = ((intBitsToFloat(uf_remappedVS[14].x) == intBitsToFloat(uf_remappedVS[14].y))?int(0xFFFFFFFF):int(0x0)); +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +R10i.y = floatBitsToInt(sin((intBitsToFloat(R126i.y))/0.1591549367)); +PS1i = R10i.y; +// 12 +backupReg0i = R126i.y; +R10i.x = floatBitsToInt(intBitsToFloat(R13i.x) * intBitsToFloat(PV1i.w)); +PV0i.x = R10i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R13i.y) * intBitsToFloat(PV1i.w)); +PV0i.y = R126i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R13i.z) * intBitsToFloat(PV1i.w)); +PV0i.z = R127i.z; +R125i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R124i.x = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +PS0i = R124i.x; +// 13 +backupReg0i = R125i.y; +backupReg0i = R125i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(R125i.y)); +R125i.y = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(backupReg0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(backupReg0i)); +PS1i = floatBitsToInt(cos((intBitsToFloat(R126i.x))/0.1591549367)); +// 14 +R2i.xyz = floatBitsToInt(vec3(intBitsToFloat(R125i.x),intBitsToFloat(R124i.y),intBitsToFloat(R126i.z)) + vec3(intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.w))); +PV0i.x = R2i.x; +PV0i.y = R2i.y; +PV0i.z = R2i.z; +R126i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R122i.x = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(R1i.y) + intBitsToFloat(R127i.x))); +PS0i = R122i.x; +// 15 +backupReg0i = R0i.w; +R1i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)))); +PV1i.x = R1i.x; +PV1i.y = R1i.x; +PV1i.z = R1i.x; +PV1i.w = R1i.x; +R125i.x = floatBitsToInt((intBitsToFloat(R9i.w) * intBitsToFloat(PS0i) + intBitsToFloat(R9i.y))); +PS1i = R125i.x; +// 16 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R6i.y = tempi.x; +R127i.x = floatBitsToInt((-(intBitsToFloat(R127i.w)) * intBitsToFloat(R1i.y) + intBitsToFloat(R126i.w))); +PS0i = R127i.x; +// 17 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.z = tempi.x; +R4i.y = floatBitsToInt(1.0 / intBitsToFloat(R127i.y)); +PS1i = R4i.y; +// 18 +backupReg0i = R1i.y; +R123i.x = floatBitsToInt((-(intBitsToFloat(R10i.y)) * intBitsToFloat(R1i.y) + intBitsToFloat(R125i.y))); +PV0i.x = R123i.x; +R1i.y = floatBitsToInt((intBitsToFloat(R9i.z) * intBitsToFloat(R127i.x) + intBitsToFloat(R9i.x))); +R126i.z = floatBitsToInt((intBitsToFloat(R124i.x) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.w))); +R125i.w = floatBitsToInt(-(intBitsToFloat(PV1i.x)) * intBitsToFloat(0x42800000)); +R1i.z = ((intBitsToFloat(uf_remappedVS[14].z) == 0.0)?int(0xFFFFFFFF):int(0x0)); +PS0i = R1i.z; +// 19 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(R10i.x),intBitsToFloat(R126i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R125i.y = floatBitsToInt((intBitsToFloat(R8i.z) * intBitsToFloat(PV0i.x) + intBitsToFloat(R8i.x))); +PS1i = R125i.y; +// 20 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R10i.x),intBitsToFloat(R126i.y),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(0x3a4ccccd)); +PS0i = R127i.w; +// 21 +backupReg0i = R8i.y; +R8i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3ab60b61)); +R8i.y = floatBitsToInt(intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[12].w)); +PV1i.y = R8i.y; +R9i.z = floatBitsToInt(intBitsToFloat(R125i.x) + 0.5); +R9i.w = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(R126i.z) + intBitsToFloat(backupReg0i))); +R7i.x = floatBitsToInt(intBitsToFloat(R125i.y) + 0.5); +PS1i = R7i.x; +// 22 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R0i.w)),vec4(intBitsToFloat(uf_remappedVS[15].x),intBitsToFloat(uf_remappedVS[15].y),intBitsToFloat(uf_remappedVS[15].z),intBitsToFloat(uf_remappedVS[15].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R8i.w = tempi.x; +R8i.z = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R127i.w)); +PS0i = R8i.z; +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[16].x),intBitsToFloat(uf_remappedVS[16].y),intBitsToFloat(uf_remappedVS[16].z),intBitsToFloat(uf_remappedVS[16].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R125i.y = tempi.x; +R125i.x = floatBitsToInt(intBitsToFloat(R8i.y) * intBitsToFloat(R8i.x)); +PS0i = R125i.x; +// 1 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[17].x),intBitsToFloat(uf_remappedVS[17].y),intBitsToFloat(uf_remappedVS[17].z),intBitsToFloat(uf_remappedVS[17].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R125i.w = floatBitsToInt(intBitsToFloat(R8i.w) + intBitsToFloat(R8i.z)); +PS1i = R125i.w; +// 2 +backupReg0i = R125i.x; +R125i.x = ((R0i.x == 0)?(PS1i):(PS1i)); +R127i.y = floatBitsToInt(intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i)); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[0].z)); +R126i.w = floatBitsToInt(intBitsToFloat(R1i.y) + 0.5); +R1i.y = floatBitsToInt(intBitsToFloat(R9i.w) + 0.5); +PS0i = R1i.y; +// 3 +backupReg0i = R0i.w; +R124i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[18].x),intBitsToFloat(uf_remappedVS[18].y),intBitsToFloat(uf_remappedVS[18].z),intBitsToFloat(uf_remappedVS[18].w)))); +PV1i.x = R124i.x; +PV1i.y = R124i.x; +PV1i.z = R124i.x; +PV1i.w = R124i.x; +R127i.x = ((R0i.x == 0)?(PV0i.z):(R1i.w)); +PS1i = R127i.x; +// 4 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +R0i.x = ((R4i.x == 0)?(R125i.x):(0x3f800000)); +R123i.y = ((backupReg0i == 0)?(R127i.y):(R127i.y)); +PV0i.y = R123i.y; +R127i.z = floatBitsToInt(-(intBitsToFloat(R9i.z)) + 1.0); +R123i.w = ((backupReg0i == 0)?(PV1i.x):(PV1i.x)); +PV0i.w = R123i.w; +R124i.y = floatBitsToInt(-(intBitsToFloat(R6i.z))); +PS0i = R124i.y; +// 5 +backupReg0i = R2i.y; +R2i.x = 0; +R8i.y = ((R4i.x == 0)?(PV0i.y):(0x3f800000)); +R8i.z = ((R4i.x == 0)?(R127i.x):(0x3f800000)); +R0i.w = ((R4i.x == 0)?(PV0i.w):(0x3f800000)); +R2i.y = floatBitsToInt(intBitsToFloat(backupReg0i) + -(intBitsToFloat(uf_remappedVS[14].w))); +PS1i = R2i.y; +// 6 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R2i.z = 0; +PS0i = R2i.z; +// 7 +R127i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R11i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),0.0))); +PV1i.x = R127i.x; +PV1i.y = R127i.x; +PV1i.z = R127i.x; +PV1i.w = R127i.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +R127i.w = floatBitsToInt(tempResultf); +PS1i = R127i.w; +// 8 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R11i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R125i.y = tempi.x; +R125i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PS1i)); +PS0i = R125i.x; +// 9 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R11i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.z = tempi.x; +R126i.y = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R127i.w)); +PS1i = R126i.y; +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R125i.y),intBitsToFloat(PV1i.x),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R125i.y),intBitsToFloat(PV1i.x),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R127i.w)); +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R125i.x),intBitsToFloat(R126i.y),intBitsToFloat(PS0i),-0.0),vec4(-(intBitsToFloat(uf_remappedVS[19].x)),-(intBitsToFloat(uf_remappedVS[19].y)),-(intBitsToFloat(uf_remappedVS[19].z)),0.0))); +tempi.x = floatBitsToInt(intBitsToFloat(tempi.x) / 2.0); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 12 +backupReg0i = R2i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(PS1i)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + 0.5); +R1i.w = 0; +R2i.x = ((R1i.z == 0)?(backupReg0i):(R125i.w)); +PS0i = R2i.x; +// 13 +backupReg0i = R2i.z; +backupReg1i = R2i.y; +PV1i.y = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +R2i.z = ((R1i.z == 0)?(backupReg0i):(R124i.y)); +R125i.w = floatBitsToInt(max(intBitsToFloat(PV0i.y), 0.0)); +PV1i.w = R125i.w; +R2i.y = ((R1i.z == 0)?(backupReg1i):(R127i.y)); +PS1i = R2i.y; +// 14 +backupReg0i = R0i.z; +R123i.x = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[20].x) + intBitsToFloat(R2i.w))); +PV0i.x = R123i.x; +R7i.y = floatBitsToInt(-(intBitsToFloat(R1i.y)) + 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + -(intBitsToFloat(uf_remappedVS[14].y))); +R123i.w = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[20].y) + intBitsToFloat(backupReg0i))); +PV0i.w = R123i.w; +R2i.w = ((R1i.z == 0)?(R1i.w):(R124i.x)); +PS0i = R2i.w; +// 15 +backupReg0i = R0i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.w) + -(1.0)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + -(1.0)); +R123i.z = floatBitsToInt((intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[20].z) + intBitsToFloat(backupReg0i))); +PV1i.z = R123i.z; +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(R4i.y)); +R7i.z = R126i.w; +PS1i = R7i.z; +// 16 +R123i.x = ((R4i.z == 0)?(PV1i.w):(0x3f800000)); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + -(1.0)); +R7i.w = R127i.z; +PS0i = R7i.w; +// 17 +backupReg0i = R3i.x; +backupReg1i = R3i.y; +R3i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.z)); +R3i.y = floatBitsToInt(intBitsToFloat(backupReg1i) * intBitsToFloat(PV0i.y)); +R0i.z = PV0i.x; +R0i.z = clampFI32(R0i.z); +R123i.w = floatBitsToInt((intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.w = R123i.w; +// 18 +backupReg0i = R3i.z; +R3i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.w)); +// 19 +predResult = (intBitsToFloat(uf_remappedVS[11].y) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(-(intBitsToFloat(R6i.z)) + -(intBitsToFloat(uf_remappedVS[11].x))); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].x)) + intBitsToFloat(uf_remappedVS[11].y)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R10i.z; +R10i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +predResult = (intBitsToFloat(uf_remappedVS[11].w) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(intBitsToFloat(R6i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].z)) + intBitsToFloat(uf_remappedVS[11].w)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R10i.z; +R10i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = ((0.0 >= intBitsToFloat(uf_remappedVS[0].w))?int(0xFFFFFFFF):int(0x0)); +R127i.y = floatBitsToInt(-(intBitsToFloat(R6i.z)) + -(intBitsToFloat(uf_remappedVS[21].x))); +R3i.w = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(R10i.z)); +PS0i = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(R6i.z)); +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.w; +R0i.x = ((PV0i.x == 0)?(backupReg0i):(0x3f800000)); +R0i.y = ((PV0i.x == 0)?(R8i.y):(0x3f800000)); +R0i.z = ((PV0i.x == 0)?(R8i.z):(0x3f800000)); +R0i.w = ((PV0i.x == 0)?(backupReg1i):(0x3f800000)); +R122i.x = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(R6i.y) + intBitsToFloat(PS0i))); +PS1i = R122i.x; +// 2 +R123i.z = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(R1i.x) + intBitsToFloat(PS1i))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].y)); +// 3 +PV1i.z = floatBitsToInt(max(intBitsToFloat(PV0i.w), 0.0)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.z)); +PS1i = floatBitsToInt(tempResultf); +// 4 +R127i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +PV0i.x = R127i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(PS1i)); +PV0i.y = R126i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(PS1i)); +PV0i.z = R127i.z; +tempResultf = log2(intBitsToFloat(PV1i.z)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +R127i.y = floatBitsToInt(tempResultf); +PS0i = R127i.y; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[22].x),intBitsToFloat(uf_remappedVS[22].y),intBitsToFloat(uf_remappedVS[22].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +// 6 +PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.x), -(intBitsToFloat(PV1i.x)))); +PV0i.y = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].z)); +PS0i = floatBitsToInt(intBitsToFloat(uf_remappedVS[23].z) * intBitsToFloat(R127i.z)); +// 7 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[23].y) * intBitsToFloat(R126i.y) + intBitsToFloat(PS0i))); +PV1i.x = R123i.x; +PV1i.w = floatBitsToInt(-(intBitsToFloat(PV0i.x)) + 1.0); +PS1i = floatBitsToInt(exp2(intBitsToFloat(PV0i.y))); +// 8 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[23].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R123i.x = clampFI32(R123i.x); +PV0i.x = R123i.x; +PV0i.z = floatBitsToInt(min(intBitsToFloat(PS1i), 1.0)); +tempResultf = log2(intBitsToFloat(PV1i.w)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0i = floatBitsToInt(tempResultf); +// 9 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[21].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].w)); +tempResultf = log2(intBitsToFloat(PV0i.x)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1i = floatBitsToInt(tempResultf); +// 10 +PV0i.z = floatBitsToInt(intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[25].w)); +R1i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[19].w)); +R127i.x = floatBitsToInt(exp2(intBitsToFloat(PV1i.y))); +PS0i = R127i.x; +// 11 +R127i.z = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].y) + intBitsToFloat(uf_remappedVS[26].y))); +R127i.w = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].x) + intBitsToFloat(uf_remappedVS[26].x))); +R126i.y = floatBitsToInt(exp2(intBitsToFloat(PV0i.z))); +PS1i = R126i.y; +// 12 +R123i.y = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[24].z) + intBitsToFloat(uf_remappedVS[26].z))); +PV0i.y = R123i.y; +// 13 +R1i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].x) + intBitsToFloat(R127i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].y) + intBitsToFloat(R127i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].z) + intBitsToFloat(PV0i.y))); +} +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R0i.x) *(origRatio / newRatio), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R3i.x), intBitsToFloat(R3i.y), intBitsToFloat(R3i.z), intBitsToFloat(R3i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +// skipped export to semanticId 255 +// export +passParameterSem3 = vec4(intBitsToFloat(R7i.x), intBitsToFloat(R7i.y), intBitsToFloat(R7i.z), intBitsToFloat(R7i.w)); +if( activeMaskStackC[1] == true ) { +// 0 +} +} diff --git a/Enhancement/XenobladeX_219_GUI/1cb8c35cca05b129_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/1cb8c35cca05b129_0000000000000000_vs.txt new file mode 100644 index 00000000..5b3ddcd2 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/1cb8c35cca05b129_0000000000000000_vs.txt @@ -0,0 +1,171 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 1cb8c35cca05b129 +//dialog box +uniform ivec4 uf_remappedVS[14]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +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 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem1.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder = attrDataSem0; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w))); +attrDecoder.xy = attrDataSem2.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R3f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +PV0f.x = intBitsToFloat(uf_remappedVS[0].w) * 1.0; +PV0f.y = intBitsToFloat(uf_remappedVS[0].z) * 1.0; +PV0f.z = intBitsToFloat(uf_remappedVS[0].y) * 1.0; +PV0f.w = intBitsToFloat(uf_remappedVS[0].x) * 1.0; +// 1 +R123f.x = (R2f.y * intBitsToFloat(uf_remappedVS[1].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R2f.y * intBitsToFloat(uf_remappedVS[1].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R2f.y * intBitsToFloat(uf_remappedVS[1].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R2f.y * intBitsToFloat(uf_remappedVS[1].x) + PV0f.w); +PV1f.w = R123f.w; +// 2 +R123f.x = (R2f.x * intBitsToFloat(uf_remappedVS[2].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R2f.x * intBitsToFloat(uf_remappedVS[2].z) + PV1f.y); +R127f.z = (R2f.x * intBitsToFloat(uf_remappedVS[2].y) + PV1f.z); +R127f.w = (R2f.x * intBitsToFloat(uf_remappedVS[2].x) + PV1f.w); +// 3 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[3].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[3].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[3].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[3].x); +// 4 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[4].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[4].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[4].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[4].x) + PV1f.w); +PV0f.w = R123f.w; +// 5 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[5].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[5].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[5].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[5].x) + PV0f.w); +PV1f.w = R123f.w; +// 6 +backupReg0f = R127f.w; +R123f.x = (R127f.w * intBitsToFloat(uf_remappedVS[6].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R127f.w * intBitsToFloat(uf_remappedVS[6].z) + PV1f.y); +R127f.z = (R127f.w * intBitsToFloat(uf_remappedVS[6].y) + PV1f.z); +R127f.w = (backupReg0f * intBitsToFloat(uf_remappedVS[6].x) + PV1f.w); +// 7 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[7].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[7].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[7].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[7].x); +// 8 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[8].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[8].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[8].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[8].x) + PV1f.w); +PV0f.w = R123f.w; +// 9 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[9].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[9].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[9].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[9].x) + PV0f.w); +PV1f.w = R123f.w; +// 10 +R2f.x = (R127f.w * intBitsToFloat(uf_remappedVS[10].x) + PV1f.w); +R2f.y = (R127f.w * intBitsToFloat(uf_remappedVS[10].y) + PV1f.z); +R2f.z = (R127f.w * intBitsToFloat(uf_remappedVS[10].z) + PV1f.y); +R2f.w = (R127f.w * intBitsToFloat(uf_remappedVS[10].w) + PV1f.x); +// 11 +PV1f.x = intBitsToFloat(uf_remappedVS[11].w) * 1.0; +PV1f.y = intBitsToFloat(uf_remappedVS[11].z) * 1.0; +PV1f.z = intBitsToFloat(uf_remappedVS[11].y) * 1.0; +PV1f.w = intBitsToFloat(uf_remappedVS[11].x) * 1.0; +// 12 +R123f.x = (R3f.y * intBitsToFloat(uf_remappedVS[12].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R3f.y * intBitsToFloat(uf_remappedVS[12].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R3f.y * intBitsToFloat(uf_remappedVS[12].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R3f.y * intBitsToFloat(uf_remappedVS[12].x) + PV1f.w); +PV0f.w = R123f.w; +// 13 +backupReg0f = R3f.x; +backupReg0f = R3f.x; +backupReg0f = R3f.x; +backupReg0f = R3f.x; +R3f.x = (backupReg0f * intBitsToFloat(uf_remappedVS[13].x) + PV0f.w); +R3f.y = (backupReg0f * intBitsToFloat(uf_remappedVS[13].y) + PV0f.z); +R3f.z = (backupReg0f * intBitsToFloat(uf_remappedVS[13].z) + PV0f.y); +R3f.w = (backupReg0f * intBitsToFloat(uf_remappedVS[13].w) + PV0f.x); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(R2f.x*(origRatio / newRatio), R2f.y, R2f.z, R2f.w); +// export +passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// export +passParameterSem1 = vec4(R3f.x, R3f.y, R3f.z, R3f.w); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/1f915b133a255dab_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/1f915b133a255dab_0000000000000000_vs.txt new file mode 100644 index 00000000..57198c1b --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/1f915b133a255dab_0000000000000000_vs.txt @@ -0,0 +1,207 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 1f915b133a255dab +//battle graph, dumped +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R126i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].w) * 1.0); +R125i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].z) * 1.0); +R125i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].y) * 1.0); +R125i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].x) * 1.0); +R124i.x = floatBitsToInt(float(PS0i)); +PS1i = R124i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +R124i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].z) * 1.0); +R124i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].y) * 1.0); +R124i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].x) * 1.0); +R125i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].w) * 1.0); +PS0i = R125i.x; +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[26].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[26].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[25].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[25].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[26].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[26].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[24].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[24].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[25].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[25].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[24].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[24].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[20].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +backupReg0i = R125i.z; +backupReg1i = R125i.w; +R125i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].y) + intBitsToFloat(backupReg0i))); +R125i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].x) + intBitsToFloat(backupReg1i))); +// 18 +backupReg0i = R126i.x; +backupReg1i = R125i.y; +R126i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].w) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].z) + intBitsToFloat(backupReg1i))); +// 19 +backupReg0i = R124i.z; +backupReg1i = R124i.w; +R124i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].w) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(backupReg0i))); +R124i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].w) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(backupReg1i))); +// 20 +backupReg0i = R125i.x; +backupReg1i = R124i.y; +R125i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].w) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(backupReg0i))); +R124i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].w) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(backupReg1i))); +// 21 +R0i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].x) + intBitsToFloat(R125i.w))); +R0i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].y) + intBitsToFloat(R125i.z))); +// 22 +R0i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].z) + intBitsToFloat(R125i.y))); +R0i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].w) + intBitsToFloat(R126i.x))); +// 23 +R2i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(R124i.w))); +R2i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(R124i.z))); +// 24 +R2i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(R124i.y))); +R2i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(R125i.x))); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R1i.x)*(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/2716141e287247da_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/2716141e287247da_0000000000000000_vs.txt new file mode 100644 index 00000000..9b3c7107 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/2716141e287247da_0000000000000000_vs.txt @@ -0,0 +1,1299 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 2716141e287247da +//transport heat waves +uniform ivec4 uf_remappedVS[21]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +layout(location = 3) in uvec4 attrDataSem3; +layout(location = 4) in uvec4 attrDataSem4; +layout(location = 5) in uvec4 attrDataSem5; +layout(location = 6) in uvec4 attrDataSem6; +layout(location = 7) in uvec4 attrDataSem7; +layout(location = 8) in uvec4 attrDataSem8; +layout(location = 9) in uvec4 attrDataSem9; +layout(location = 10) in uvec4 attrDataSem10; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 1) out vec4 passParameterSem0; +layout(location = 2) out vec4 passParameterSem1; +layout(location = 3) out vec4 passParameterSem2; +layout(location = 4) out vec4 passParameterSem3; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +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 R11i = ivec4(0); +ivec4 R12i = ivec4(0); +ivec4 R13i = ivec4(0); +ivec4 R14i = ivec4(0); +ivec4 R122i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +bool activeMaskStack[5]; +bool activeMaskStackC[6]; +activeMaskStack[0] = false; +activeMaskStack[1] = false; +activeMaskStack[2] = false; +activeMaskStack[3] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStackC[2] = false; +activeMaskStackC[3] = false; +activeMaskStackC[4] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = ivec4(gl_VertexID, 0, 0, gl_InstanceID); +attrDecoder.xy = attrDataSem0.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder = attrDataSem1; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R2i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem4; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R5i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem5; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R6i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xyz = attrDataSem6.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R7i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder.xyz = attrDataSem3.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R4i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder = attrDataSem7; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R8i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem8; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R9i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xy = attrDataSem10.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R11i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xy = attrDataSem9.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R10i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem2.xyzw)/255.0); +R3i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R126i.x = floatBitsToInt(max(intBitsToFloat(R4i.x), -(intBitsToFloat(R4i.x)))); +PV0i.x = R126i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R6i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.y = R123i.y; +R126i.z = floatBitsToInt(max(intBitsToFloat(R4i.y), -(intBitsToFloat(R4i.y)))); +PV0i.z = R126i.z; +R126i.w = R4i.z; +R127i.z = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.z; +// 1 +PV1i.x = floatBitsToInt(fract(intBitsToFloat(PV0i.y))); +R123i.y = floatBitsToInt((intBitsToFloat(R6i.z) * intBitsToFloat(0x3e22f983) + 0.5)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[0].x) + -(0.5)); +R127i.w = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(PV0i.x)); +R127i.x = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(PV0i.z)); +PS1i = R127i.x; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.x = R123i.x; +PV0i.y = floatBitsToInt(fract(intBitsToFloat(R127i.z))); +R127i.z = floatBitsToInt(fract(intBitsToFloat(PV1i.y))); +PV0i.w = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(R126i.w)); +R124i.w = ((intBitsToFloat(PV1i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PS0i = R124i.w; +// 3 +PV1i.x = floatBitsToInt(-(intBitsToFloat(R126i.w)) + intBitsToFloat(PV0i.w)); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R126i.z)) + intBitsToFloat(R127i.x)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R126i.x)) + intBitsToFloat(R127i.w)); +R4i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3e22f983)); +R127i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PS1i = R127i.x; +// 4 +backupReg0i = R127i.z; +backupReg1i = R126i.x; +R126i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R126i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(R124i.w) + intBitsToFloat(R126i.z))); +R127i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +R126i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +R125i.x = R5i.x; +R125i.x = floatBitsToInt(intBitsToFloat(R125i.x) * 2.0); +PS0i = R125i.x; +// 5 +R124i.x = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R7i.y)); +R126i.y = floatBitsToInt(intBitsToFloat(R4i.x) * intBitsToFloat(R7i.x)); +R126i.z = R5i.z; +R126i.z = floatBitsToInt(intBitsToFloat(R126i.z) * 2.0); +R127i.w = R5i.y; +R127i.w = floatBitsToInt(intBitsToFloat(R127i.w) * 2.0); +R125i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(R7i.z)); +PS1i = R125i.w; +// 6 +PV0i.x = R7i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) / 2.0); +R125i.y = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(0x3e22f983)); +PV0i.z = 0; +PV0i.w = R7i.y; +PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) / 2.0); +R124i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(0x3e22f983)); +PS0i = R124i.y; +// 7 +R0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R126i.w)); +R0i.y = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R127i.y)); +R11i.z = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R126i.x)); +R126i.w = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R125i.x)); +R127i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R127i.w)); +PS1i = R127i.x; +// 8 +R126i.x = R5i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R126i.x) * 2.0); +PV0i.y = R5i.z; +PV0i.y = floatBitsToInt(intBitsToFloat(PV0i.y) * 2.0); +PV0i.z = R5i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0); +R127i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R126i.z)); +R125i.x = R5i.w; +R125i.x = floatBitsToInt(intBitsToFloat(R125i.x) * 2.0); +PS0i = R125i.x; +// 9 +backupReg0i = R124i.x; +backupReg1i = R126i.y; +R124i.x = floatBitsToInt(-(intBitsToFloat(R4i.z)) + intBitsToFloat(R125i.w)); +R126i.y = floatBitsToInt(-(intBitsToFloat(R4i.y)) + intBitsToFloat(backupReg0i)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R4i.x)) + intBitsToFloat(backupReg1i)); +R0i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(PV0i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PV0i.y)); +PS1i = R127i.z; +// 10 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +backupReg1i = R0i.y; +backupReg1i = R0i.y; +R0i.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R11i.z),0.0))); +PV0i.x = R0i.x; +PV0i.y = R0i.x; +PV0i.z = R0i.x; +PV0i.w = R0i.x; +R125i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.x))); +PS0i = R125i.w; +// 11 +backupReg0i = R126i.x; +backupReg1i = R126i.y; +R126i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(backupReg0i)); +R126i.y = floatBitsToInt((intBitsToFloat(R124i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.z))); +R126i.z = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.y))); +R124i.w = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R125i.x)); +R124i.x = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R125i.x)); +PS1i = R124i.x; +// 12 +PV0i.x = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w)); +PV0i.y = floatBitsToInt(intBitsToFloat(R127i.x) + intBitsToFloat(R127i.w)); +R125i.z = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R125i.x)); +R127i.w = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.x)); +R1i.z = 0; +PS0i = R1i.z; +// 13 +R5i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(R7i.x)); +PV1i.x = R5i.x; +R0i.y = floatBitsToInt(intBitsToFloat(R1i.y) * intBitsToFloat(R7i.y)); +PV1i.y = R0i.y; +R0i.z = floatBitsToInt(-(intBitsToFloat(PV0i.x)) + 1.0); +R7i.w = floatBitsToInt(-(intBitsToFloat(PV0i.y)) + 1.0); +R4i.x = 0; +PS1i = R4i.x; +// 14 +R13i.xyz = floatBitsToInt(vec3(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(R1i.z)) + vec3(intBitsToFloat(R125i.w),intBitsToFloat(R126i.z),intBitsToFloat(R126i.y))); +R10i.w = floatBitsToInt(intBitsToFloat(R126i.x) + -(intBitsToFloat(R124i.x))); +R12i.y = 0; +PS0i = R12i.y; +// 15 +R12i.x = 0x3f800000; +R7i.y = 0x3f800000; +R12i.z = 0; +R11i.w = floatBitsToInt(intBitsToFloat(R127i.z) + intBitsToFloat(R124i.w)); +R12i.w = floatBitsToInt(intBitsToFloat(R126i.x) + intBitsToFloat(R124i.x)); +PS1i = R12i.w; +// 16 +R1i.z = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(R125i.z)); +R5i.w = floatBitsToInt(intBitsToFloat(R0i.w) + -(intBitsToFloat(R125i.z))); +R13i.w = floatBitsToInt(intBitsToFloat(R127i.z) + -(intBitsToFloat(R124i.w))); +PS0i = R13i.w; +// 17 +R4i.z = floatBitsToInt(-(intBitsToFloat(R127i.w)) + 1.0); +R7i.z = 0; +PS1i = R7i.z; +// 18 +R14i.z = 0; +PS0i = floatBitsToInt(sin((intBitsToFloat(R4i.w))/0.1591549367)); +// 19 +R126i.x = PS0i; +R0i.w = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +PS1i = floatBitsToInt(cos((intBitsToFloat(R4i.w))/0.1591549367)); +// 20 +R127i.w = PS1i; +R1i.w = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +PS0i = R1i.w; +// 21 +PS1i = floatBitsToInt(sin((intBitsToFloat(R125i.y))/0.1591549367)); +// 22 +R5i.y = floatBitsToInt(intBitsToFloat(R126i.x) * intBitsToFloat(PS1i)); +R5i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS1i)); +R2i.w = floatBitsToInt(-(intBitsToFloat(PS1i)) * 1.0); +PS0i = floatBitsToInt(cos((intBitsToFloat(R125i.y))/0.1591549367)); +// 23 +R4i.y = floatBitsToInt(intBitsToFloat(R126i.x) * intBitsToFloat(PS0i)); +R6i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +R4i.w = floatBitsToInt(intBitsToFloat(PS0i) * 1.0); +R127i.w = floatBitsToInt(sin((intBitsToFloat(R124i.y))/0.1591549367)); +PS1i = R127i.w; +// 24 +R6i.x = PS1i; +PS0i = floatBitsToInt(cos((intBitsToFloat(R124i.y))/0.1591549367)); +// 25 +R5i.x = PS0i; +R0i.y = floatBitsToInt(-(intBitsToFloat(R127i.w))); +R6i.y = PS0i; +PS1i = R6i.y; +// 26 +R10i.z = floatBitsToInt(sqrt(intBitsToFloat(R0i.x))); +PS0i = R10i.z; +// 27 +predResult = (intBitsToFloat(0xc0200000) > intBitsToFloat(R6i.w)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.xyz = ivec3(R5i.z,R0i.w,R6i.z); +PV0i.x = R127i.x; +PV0i.y = R127i.y; +PV0i.z = R127i.z; +R127i.w = 0; +R12i.x = uf_remappedVS[1].z; +PS0i = R12i.x; +// 1 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +// 2 +backupReg0i = R127i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +// 3 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R12i.y = uf_remappedVS[4].z; +PS1i = R12i.y; +// 4 +R12i.z = uf_remappedVS[5].z; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV1i.x)); +PS0i = floatBitsToInt(tempResultf); +// 5 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS0i)); +PV1i.x = R126i.x; +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS0i)); +PV1i.y = R127i.y; +// 6 +PV0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * -(intBitsToFloat(PV1i.x))); +PV0i.y = floatBitsToInt(intBitsToFloat(R13i.x) * intBitsToFloat(PV1i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PV1i.y)); +PV0i.w = floatBitsToInt(intBitsToFloat(R13i.x) * -(intBitsToFloat(PV1i.x))); +// 7 +backupReg0i = R127i.y; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.z))); +R123i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.w))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.y))); +PV1i.w = R123i.w; +// 8 +R0i.x = PV1i.z; +PV0i.x = R0i.x; +R0i.y = PV1i.w; +PV0i.y = R0i.y; +R4i.x = PV1i.x; +PS0i = R4i.x; +// 9 +R6i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV1i.x = R6i.x; +PV1i.y = R6i.x; +PV1i.z = R6i.x; +PV1i.w = R6i.x; +R4i.y = R127i.y; +PS1i = R4i.y; +// 10 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R6i.y = tempi.x; +// 11 +backupReg0i = R0i.x; +backupReg1i = R0i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.z = tempi.x; +// 12 +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV0i.x = R13i.x; +PV0i.y = R13i.x; +PV0i.z = R13i.x; +PV0i.w = R13i.x; +// 13 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.y = tempi.x; +// 14 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R13i.z = tempi.x; +} +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 +predResult = (0.5 > intBitsToFloat(R6i.w)); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +backupReg0i = R0i.y; +R7i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),0.0))); +PV0i.x = R7i.x; +PV0i.y = R7i.x; +PV0i.z = R7i.x; +PV0i.w = R7i.x; +R4i.x = uf_remappedVS[1].x; +PS0i = R4i.x; +// 1 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.y = tempi.x; +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R14i.z) * intBitsToFloat(R12i.z)); +R4i.y = uf_remappedVS[1].y; +R4i.z = uf_remappedVS[1].z; +// 3 +backupReg0i = R0i.y; +R0i.xyz = ivec3(uf_remappedVS[4].x,uf_remappedVS[4].y,uf_remappedVS[4].z); +R122i.x = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(backupReg0i) + intBitsToFloat(PV0i.x))); +PS1i = R122i.x; +// 4 +backupReg0i = R5i.x; +R5i.xyz = ivec3(uf_remappedVS[5].x,uf_remappedVS[5].y,uf_remappedVS[5].z); +PV0i.w = floatBitsToInt(intBitsToFloat(R14i.z) * intBitsToFloat(R12i.z)); +R14i.x = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(backupReg0i) + intBitsToFloat(PS1i))); +PS0i = R14i.x; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(PV0i.w),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R10i.y = tempi.x; +R1i.z = 0; +PS1i = R1i.z; +// 6 +predResult = (intBitsToFloat(0xbfc00000) > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = uf_remappedVS[1].w; +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].z) * 1.0); +R126i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[4].w))); +// 1 +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[1].y)); +R4i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * 0.0 + intBitsToFloat(PV0i.y))); +PS1i = R4i.z; +// 2 +R4i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.z))); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[1].y)); +// 3 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[4].y)); +R0i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * 0.0 + intBitsToFloat(R127i.z))); +// 4 +R0i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[4].y)); +// 5 +R126i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 6 +R126i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 7 +R4i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.y))); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[5].z) * 1.0); +// 8 +R5i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.y))); +R0i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w))); +R5i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * 0.0 + intBitsToFloat(PV1i.w))); +R5i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R126i.x))); +PS0i = R5i.y; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +activeMaskStack[4] = activeMaskStack[3]; +activeMaskStackC[5] = activeMaskStackC[4]; +// 0 +predResult = (0.0 > intBitsToFloat(R6i.w)); +activeMaskStack[4] = predResult; +activeMaskStackC[5] = predResult == true && activeMaskStackC[4] == true; +} +else { +activeMaskStack[4] = false; +activeMaskStackC[5] = false; +} +if( activeMaskStackC[5] == true ) { +// 0 +R4i.y = 0; +R4i.z = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[5].x))); +R0i.y = 0x3f800000; +PS0i = R0i.y; +// 1 +R5i.y = 0; +R0i.z = 0; +R5i.z = uf_remappedVS[1].x; +PS1i = R5i.z; +// 2 +R11i.z = 0; +// 3 +R7i.z = R10i.z; +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +R6i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV0i.x = R6i.x; +PV0i.y = R6i.x; +PV0i.z = R6i.x; +PV0i.w = R6i.x; +R12i.x = R4i.z; +PS0i = R12i.x; +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.z; +backupReg1i = R0i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(backupReg1i),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.y = tempi.x; +R12i.y = backupReg1i; +PS1i = R12i.y; +// 2 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R6i.z = tempi.x; +R12i.z = R5i.z; +PS0i = R12i.z; +// 3 +backupReg0i = R0i.z; +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R14i.x),intBitsToFloat(R10i.y),intBitsToFloat(R1i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV1i.x = R13i.x; +PV1i.y = R13i.x; +PV1i.z = R13i.x; +PV1i.w = R13i.x; +PS1i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(backupReg0i)); +// 4 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R14i.x),intBitsToFloat(R10i.y),intBitsToFloat(PS1i),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),1.0,0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R13i.y = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R5i.z)); +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R14i.x),intBitsToFloat(R10i.y),intBitsToFloat(PS0i),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.z = tempi.x; +} +activeMaskStack[2] = activeMaskStack[2] == false; +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +predResult = (1.5 > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +backupReg0i = R13i.x; +R13i.x = R13i.z; +R13i.z = backupReg0i; +R7i.x = R14i.z; +PS0i = R7i.x; +// 1 +R7i.y = R1i.y; +R7i.z = R1i.x; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = ((intBitsToFloat(0x40600000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +PV0i.x = R127i.x; +R127i.y = ((intBitsToFloat(0x40200000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +// 1 +R123i.x = ((PV0i.x == 0)?(R13i.y):(R13i.x)); +PV1i.x = R123i.x; +R123i.y = ((PV0i.x == 0)?(R13i.z):(R13i.z)); +PV1i.y = R123i.y; +R123i.z = ((PV0i.x == 0)?(R1i.y):(R1i.x)); +PV1i.z = R123i.z; +R123i.w = ((PV0i.x == 0)?(R13i.x):(R13i.y)); +PV1i.w = R123i.w; +R127i.z = ((PV0i.x == 0)?(R1i.x):(R1i.y)); +PS1i = R127i.z; +// 2 +backupReg0i = R13i.x; +backupReg1i = R13i.y; +R13i.x = ((R127i.y == 0)?(PV1i.x):(backupReg0i)); +R13i.y = ((R127i.y == 0)?(PV1i.w):(R13i.z)); +R13i.z = ((R127i.y == 0)?(PV1i.y):(backupReg1i)); +R123i.w = ((R127i.x == 0)?(R14i.z):(R14i.z)); +PV0i.w = R123i.w; +R7i.x = ((R127i.y == 0)?(PV1i.z):(R1i.x)); +PS0i = R7i.x; +// 3 +backupReg0i = R7i.y; +R12i.x = ((R127i.y == 0)?(0):(R4i.x)); +R7i.y = ((R127i.y == 0)?(R127i.z):(R14i.z)); +R7i.z = ((R127i.y == 0)?(PV0i.w):(R1i.y)); +R12i.y = ((R127i.y == 0)?(0):(backupReg0i)); +PS1i = R12i.y; +// 4 +backupReg0i = R12i.z; +R12i.z = ((R127i.y == 0)?(0x3f800000):(backupReg0i)); +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R6i.x)); +PV0i.y = floatBitsToInt(intBitsToFloat(R6i.z) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R6i.x)); +PV0i.w = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R6i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R6i.y)); +PS0i = R127i.z; +// 1 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.w) * 0.0 + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R5i.z) * 1.0); +R125i.z = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R5i.x) + intBitsToFloat(PV0i.z))); +PV1i.z = R125i.z; +R126i.w = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R0i.y) + intBitsToFloat(PV0i.w))); +PV1i.w = R126i.w; +R124i.w = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R6i.x)); +PS1i = R124i.w; +// 2 +R124i.x = floatBitsToInt((intBitsToFloat(R1i.w) * 0.0 + intBitsToFloat(R0i.w))); +R126i.y = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R6i.y)); +R126i.z = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(PV1i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(PV1i.z)); +R126i.x = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(PV1i.x)); +PS0i = R126i.x; +// 3 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R5i.x) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(R4i.w) * 0.0 + intBitsToFloat(R127i.y))); +R124i.z = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R0i.y) + intBitsToFloat(R127i.z))); +R125i.w = floatBitsToInt(intBitsToFloat(R5i.w) * intBitsToFloat(R125i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.w) * intBitsToFloat(R126i.w)); +PS1i = R127i.z; +// 4 +backupReg0i = R126i.x; +backupReg1i = R126i.z; +R126i.x = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg0i))); +PV0i.y = floatBitsToInt(intBitsToFloat(R5i.w) * intBitsToFloat(R125i.x)); +R126i.z = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.w))); +R127i.w = floatBitsToInt((intBitsToFloat(R1i.z) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg1i))); +R11i.z = 0; +PS0i = R11i.z; +// 5 +backupReg0i = R125i.x; +backupReg1i = R127i.z; +R125i.x = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R126i.w)); +R127i.y = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R125i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(backupReg0i)); +R126i.w = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg1i))); +R125i.z = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.y))); +PS1i = R125i.z; +// 6 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R125i.w))); +R124i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.z))); +R126i.z = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i))); +// 7 +backupReg0i = R125i.x; +backupReg1i = R127i.z; +R125i.x = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R127i.w))); +PV1i.y = R126i.y; +R127i.z = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R125i.z; +backupReg1i = R127i.y; +R124i.x = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.x))); +R127i.y = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(PV1i.y)); +R125i.z = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i))); +R123i.w = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +PV0i.w = R123i.w; +PS0i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R126i.z)); +// 9 +backupReg0i = R124i.z; +backupReg1i = R125i.y; +R0i.x = floatBitsToInt((intBitsToFloat(R7i.w) * intBitsToFloat(R127i.x) + intBitsToFloat(PV0i.w))); +R125i.y = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R126i.w))); +R124i.z = floatBitsToInt((intBitsToFloat(R7i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.x))); +R0i.w = floatBitsToInt((intBitsToFloat(R7i.w) * intBitsToFloat(backupReg1i) + intBitsToFloat(R127i.z))); +R122i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R126i.y) + intBitsToFloat(PS0i))); +PS1i = R122i.x; +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R124i.y),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.z = tempi.x; +R127i.w = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R124i.y) + intBitsToFloat(PS1i))); +PS0i = R127i.w; +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R124i.x),intBitsToFloat(R125i.y),intBitsToFloat(R125i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R124i.w = tempi.x; +R126i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].x)); +PS1i = R126i.w; +// 12 +backupReg0i = R127i.z; +R127i.x = floatBitsToInt((intBitsToFloat(R7i.z) * intBitsToFloat(R126i.z) + intBitsToFloat(R127i.y))); +R127i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[6].z)); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].y)); +R125i.w = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[6].x)); +R126i.y = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[6].y)); +PS0i = R126i.y; +// 13 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R124i.z),intBitsToFloat(R0i.w),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +R125i.x = floatBitsToInt((intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R126i.w))); +PS1i = R125i.x; +// 14 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R7i.x) * intBitsToFloat(R124i.y) + intBitsToFloat(backupReg0i))); +PV0i.y = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(R124i.x)); +R123i.z = floatBitsToInt((intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R127i.y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R127i.z))); +PV0i.w = R123i.w; +PS0i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R125i.z)); +// 15 +R6i.x = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R125i.x))); +R6i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.w))); +R6i.z = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.z))); +R123i.w = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PS0i))); +PV1i.w = R123i.w; +R122i.x = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PV0i.y))); +PS1i = R122i.x; +// 16 +backupReg0i = R124i.x; +R124i.x = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(backupReg0i) + intBitsToFloat(PV1i.w))); +PV0i.x = R124i.x; +R125i.y = floatBitsToInt((intBitsToFloat(R7i.z) * intBitsToFloat(R125i.z) + intBitsToFloat(PS1i))); +PV0i.y = R125i.y; +R125i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[6].z)); +PV0i.w = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[6].x)); +PS0i = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[6].y)); +// 17 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R125i.w))); +R124i.y = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV0i.w))); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].z)); +R125i.w = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R126i.y))); +R126i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PS0i))); +PS1i = R126i.x; +// 18 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R124i.z),intBitsToFloat(R0i.w),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.y = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R124i.x) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R125i.z))); +PS0i = R127i.y; +// 19 +backupReg0i = R0i.x; +backupReg1i = R127i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R124i.z),intBitsToFloat(R0i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.z = tempi.x; +R127i.w = floatBitsToInt((intBitsToFloat(R125i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(backupReg1i))); +PS1i = R127i.w; +// 20 +R12i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R127i.x))); +R12i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R125i.w))); +R12i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R127i.y))); +R13i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R124i.y))); +PS0i = R13i.x; +// 21 +R13i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R126i.x))); +R13i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R127i.w))); +// 22 +R7i.z = R10i.z; +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].y) * 1.0); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].x) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].w) * 1.0); +PV0i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].z) * 1.0); +R1i.w = 0; +PS0i = R1i.w; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].y) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].x) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].w) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].z) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +R5i.z = R3i.w; +R5i.z = floatBitsToInt(intBitsToFloat(R5i.z) * 2.0); +PS1i = R5i.z; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].w) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +R0i.x = ((0.0 >= intBitsToFloat(PS1i))?int(0xFFFFFFFF):int(0x0)); +PS0i = R0i.x; +// 3 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R124i.y = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.x))); +PV1i.y = R124i.y; +R125i.z = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.w))); +PV1i.z = R125i.z; +R0i.w = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].w) + intBitsToFloat(PV0i.z))); +PV1i.w = R0i.w; +R127i.w = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PS1i = R127i.w; +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.w)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 5 +PV1i.x = floatBitsToInt(-(intBitsToFloat(R11i.z)) + -(intBitsToFloat(PV0i.x))); +PV1i.y = floatBitsToInt(intBitsToFloat(R7i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].y) + -(intBitsToFloat(0x3dcccccd))); +PV1i.w = floatBitsToInt(-(intBitsToFloat(R7i.z)) + intBitsToFloat(uf_remappedVS[11].x)); +PS1i = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].w) + -(intBitsToFloat(0x3dcccccd))); +// 6 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.x) + -(intBitsToFloat(PV1i.y))); +R126i.y = ((intBitsToFloat(PS1i) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV0i.z = floatBitsToInt(-(intBitsToFloat(PV1i.x)) + intBitsToFloat(PV1i.w)); +R126i.w = ((intBitsToFloat(PV1i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +R125i.y = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[12].w)) + 1.0); +PS0i = R125i.y; +// 7 +R2i.x = ((-(1.0) > intBitsToFloat(uf_remappedVS[0].y))?int(0xFFFFFFFF):int(0x0)); +R123i.y = ((intBitsToFloat(PV0i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(fract(intBitsToFloat(R127i.w))); +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +PS1i = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +// 8 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(R126i.y)); +R123i.y = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.y = R123i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R126i.w)); +R123i.w = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.w = R123i.w; +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].x) + -(1.0)); +PS0i = R127i.z; +// 9 +R127i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(0x3e22f983)); +PV1i.x = R127i.x; +PV1i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].y) + -(1.0)); +R126i.z = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(0x3e22f983)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(PV0i.x)); +R126i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].z) + -(1.0)); +PS1i = R126i.x; +// 10 +R4i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R0i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +PV0i.z = floatBitsToInt(-(intBitsToFloat(PV1i.w)) + -(0.0)); +R125i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[14].x) + -(intBitsToFloat(uf_remappedVS[14].y))); +R126i.w = floatBitsToInt(sin((intBitsToFloat(PV1i.x))/0.1591549367)); +PS0i = R126i.w; +// 11 +R5i.x = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R127i.y = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +R4i.z = ((intBitsToFloat(uf_remappedVS[14].x) == intBitsToFloat(uf_remappedVS[14].y))?int(0xFFFFFFFF):int(0x0)); +R123i.w = ((intBitsToFloat(PV0i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +R127i.z = floatBitsToInt(cos((intBitsToFloat(R127i.x))/0.1591549367)); +PS1i = R127i.z; +// 12 +R126i.x = floatBitsToInt(intBitsToFloat(R6i.x) * intBitsToFloat(PV1i.w)); +PV0i.x = R126i.x; +R11i.y = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(PV1i.w)); +PV0i.y = R11i.y; +R124i.z = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(PV1i.w)); +PV0i.z = R124i.z; +R127i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R126i.y = floatBitsToInt(sin((intBitsToFloat(R126i.z))/0.1591549367)); +PS0i = R126i.y; +// 13 +backupReg0i = R125i.y; +backupReg0i = R125i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(R125i.y)); +R125i.y = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(backupReg0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(backupReg0i)); +R127i.x = floatBitsToInt(cos((intBitsToFloat(R126i.z))/0.1591549367)); +PS1i = R127i.x; +// 14 +R11i.x = floatBitsToInt(intBitsToFloat(R125i.x) + intBitsToFloat(PV1i.x)); +PV0i.x = R11i.x; +R2i.y = floatBitsToInt(intBitsToFloat(R124i.y) + intBitsToFloat(PV1i.z)); +PV0i.y = R2i.y; +R0i.z = floatBitsToInt(intBitsToFloat(R125i.z) + intBitsToFloat(PV1i.w)); +PV0i.z = R0i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R125i.z = floatBitsToInt((-(intBitsToFloat(R126i.w)) * intBitsToFloat(R1i.y) + intBitsToFloat(R127i.w))); +PS0i = R125i.z; +// 15 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R4i.y = tempi.x; +R126i.z = floatBitsToInt((-(intBitsToFloat(R126i.y)) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.w))); +PS1i = R126i.z; +// 16 +backupReg0i = R127i.y; +backupReg1i = R125i.w; +R125i.x = floatBitsToInt(-(intBitsToFloat(PV1i.x)) * intBitsToFloat(0x42800000)); +R127i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(R1i.y) + intBitsToFloat(backupReg0i))); +R1i.z = ((intBitsToFloat(uf_remappedVS[14].z) == 0.0)?int(0xFFFFFFFF):int(0x0)); +R125i.w = floatBitsToInt((intBitsToFloat(R8i.z) * intBitsToFloat(R125i.z) + intBitsToFloat(R8i.x))); +R6i.x = floatBitsToInt(1.0 / intBitsToFloat(backupReg1i)); +PS0i = R6i.x; +// 17 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(R11i.y),intBitsToFloat(R124i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R1i.x = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(R125i.y))); +PS1i = R1i.x; +// 18 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(R11i.y),intBitsToFloat(R124i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.x = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(0x3a4ccccd)); +PS0i = R126i.x; +// 19 +backupReg0i = R125i.x; +backupReg1i = R125i.w; +R125i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3ab60b61)); +R11i.y = floatBitsToInt((intBitsToFloat(R9i.z) * intBitsToFloat(R126i.z) + intBitsToFloat(R9i.x))); +R2i.z = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(R127i.y) + intBitsToFloat(R8i.y))); +R125i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[12].w)); +PV1i.w = R125i.w; +R7i.x = floatBitsToInt(intBitsToFloat(backupReg1i) + 0.5); +PS1i = R7i.x; +// 20 +backupReg0i = R0i.z; +backupReg1i = R0i.w; +backupReg2i = R126i.x; +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R2i.y),intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i)),vec4(intBitsToFloat(uf_remappedVS[15].x),intBitsToFloat(uf_remappedVS[15].y),intBitsToFloat(uf_remappedVS[15].z),intBitsToFloat(uf_remappedVS[15].w)))); +PV0i.x = R126i.x; +PV0i.y = R126i.x; +PV0i.z = R126i.x; +PV0i.w = R126i.x; +R126i.z = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(backupReg2i)); +PS0i = R126i.z; +// 21 +backupReg0i = R0i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R2i.y),intBitsToFloat(backupReg0i),intBitsToFloat(R0i.w)),vec4(intBitsToFloat(uf_remappedVS[16].x),intBitsToFloat(uf_remappedVS[16].y),intBitsToFloat(uf_remappedVS[16].z),intBitsToFloat(uf_remappedVS[16].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R8i.w = tempi.x; +R8i.y = floatBitsToInt(intBitsToFloat(R125i.w) * intBitsToFloat(R125i.x)); +PS1i = R8i.y; +// 22 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R2i.y),intBitsToFloat(R0i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[17].x),intBitsToFloat(uf_remappedVS[17].y),intBitsToFloat(uf_remappedVS[17].z),intBitsToFloat(uf_remappedVS[17].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R8i.z = tempi.x; +R8i.x = floatBitsToInt(intBitsToFloat(R126i.x) + intBitsToFloat(R126i.z)); +PS0i = R8i.x; +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(R8i.z) * intBitsToFloat(uf_remappedVS[0].z)); +R5i.y = floatBitsToInt(intBitsToFloat(R2i.z) + 0.5); +R126i.z = ((R2i.x == 0)?(R8i.x):(R8i.x)); +R125i.w = floatBitsToInt(intBitsToFloat(R8i.w) + intBitsToFloat(R8i.y)); +R9i.x = floatBitsToInt(intBitsToFloat(R11i.y) + 0.5); +PS0i = R9i.x; +// 1 +backupReg0i = R0i.z; +backupReg1i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R2i.y),intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i)),vec4(intBitsToFloat(uf_remappedVS[18].x),intBitsToFloat(uf_remappedVS[18].y),intBitsToFloat(uf_remappedVS[18].z),intBitsToFloat(uf_remappedVS[18].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R125i.y = tempi.x; +R126i.x = ((R2i.x == 0)?(PV0i.x):(R1i.w)); +PS1i = R126i.x; +// 2 +backupReg0i = R2i.x; +backupReg0i = R2i.x; +R2i.x = ((R0i.x == 0)?(R126i.z):(0x3f800000)); +R123i.y = ((backupReg0i == 0)?(R125i.w):(R125i.w)); +PV0i.y = R123i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(R13i.z) * intBitsToFloat(R13i.z)); +R123i.w = ((backupReg0i == 0)?(PV1i.x):(PV1i.x)); +PV0i.w = R123i.w; +R122i.x = floatBitsToInt((intBitsToFloat(R9i.w) * intBitsToFloat(R1i.x) + intBitsToFloat(R9i.y))); +PS0i = R122i.x; +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(R13i.y) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.z))); +PV1i.x = R123i.x; +R8i.y = ((R0i.x == 0)?(PV0i.y):(0x3f800000)); +R0i.z = ((R0i.x == 0)?(R126i.x):(0x3f800000)); +R0i.w = ((R0i.x == 0)?(PV0i.w):(0x3f800000)); +R6i.y = floatBitsToInt(intBitsToFloat(PS0i) + 0.5); +PS1i = R6i.y; +// 4 +R124i.x = floatBitsToInt(-(intBitsToFloat(R4i.y))); +R127i.y = floatBitsToInt((intBitsToFloat(R13i.x) * intBitsToFloat(R13i.x) + intBitsToFloat(PV1i.x))); +PV0i.z = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(uf_remappedVS[2].z)); +PV0i.w = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(uf_remappedVS[3].z)); +R0i.x = 0; +PS0i = R0i.x; +// 5 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(PV0i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),1.0,0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +R122i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(uf_remappedVS[3].y) + intBitsToFloat(PV0i.w))); +PS1i = R122i.x; +// 6 +backupReg0i = R127i.y; +R1i.x = ((R1i.z == 0)?(R0i.x):(R8i.x)); +R127i.y = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(uf_remappedVS[3].x) + intBitsToFloat(PS1i))); +PV0i.z = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(uf_remappedVS[10].z)); +tempResultf = 1.0 / sqrt(intBitsToFloat(backupReg0i)); +R125i.x = floatBitsToInt(tempResultf); +PS0i = R125i.x; +// 7 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(PV0i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.z = tempi.x; +R127i.x = floatBitsToInt(intBitsToFloat(R13i.x) * intBitsToFloat(PS0i)); +PS1i = R127i.x; +// 8 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV1i.x),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV1i.x),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = floatBitsToInt(intBitsToFloat(R13i.y) * intBitsToFloat(R125i.x)); +PS0i = R127i.y; +// 9 +R1i.y = floatBitsToInt(intBitsToFloat(R2i.y) + -(intBitsToFloat(uf_remappedVS[14].w))); +PV1i.z = floatBitsToInt(intBitsToFloat(R13i.z) * intBitsToFloat(R125i.x)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV1i.z),-0.0),vec4(-(intBitsToFloat(uf_remappedVS[19].x)),-(intBitsToFloat(uf_remappedVS[19].y)),-(intBitsToFloat(uf_remappedVS[19].z)),0.0))); +tempi.x = floatBitsToInt(intBitsToFloat(tempi.x) / 2.0); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(PS1i)); +// 11 +backupReg0i = R1i.y; +PV1i.x = floatBitsToInt(max(intBitsToFloat(PS0i), -(intBitsToFloat(PS0i)))); +R1i.y = ((R1i.z == 0)?(backupReg0i):(R125i.w)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) + 0.5); +R1i.w = 0; +PV1i.w = R1i.w; +R2i.z = 0; +PS1i = R2i.z; +// 12 +backupReg0i = R1i.z; +backupReg0i = R1i.z; +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.x) + -(intBitsToFloat(uf_remappedVS[14].y))); +PV0i.y = floatBitsToInt(max(intBitsToFloat(PV1i.z), 0.0)); +R1i.z = ((backupReg0i == 0)?(PS1i):(R124i.x)); +R1i.w = ((backupReg0i == 0)?(PV1i.w):(R125i.y)); +R7i.y = floatBitsToInt(-(intBitsToFloat(R5i.y)) + 1.0); +PS0i = R7i.y; +// 13 +backupReg0i = R0i.y; +R123i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[20].x) + intBitsToFloat(R4i.x))); +PV1i.x = R123i.x; +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(R6i.x)); +R123i.z = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[20].z) + intBitsToFloat(R5i.x))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[20].y) + intBitsToFloat(backupReg0i))); +PV1i.w = R123i.w; +R9i.y = floatBitsToInt(-(intBitsToFloat(R6i.y)) + 1.0); +PS1i = R9i.y; +// 14 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) + -(1.0)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + -(1.0)); +R123i.z = ((R4i.z == 0)?(PV1i.y):(0x3f800000)); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + -(1.0)); +R7i.z = uf_remappedVS[12].x; +PS0i = R7i.z; +// 15 +R123i.y = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.w = R123i.w; +R0i.y = PV0i.z; +R0i.y = clampFI32(R0i.y); +PS1i = R0i.y; +// 16 +backupReg0i = R3i.x; +backupReg1i = R3i.y; +backupReg2i = R3i.z; +R3i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.z)); +R3i.y = floatBitsToInt(intBitsToFloat(backupReg1i) * intBitsToFloat(PV1i.y)); +R3i.z = floatBitsToInt(intBitsToFloat(backupReg2i) * intBitsToFloat(PV1i.w)); +R7i.w = uf_remappedVS[12].y; +R9i.z = floatBitsToInt(intBitsToFloat(R10i.x) * intBitsToFloat(0x3c800000)); +PS0i = R9i.z; +// 17 +R9i.w = 0x3f800000; +// 18 +predResult = (intBitsToFloat(uf_remappedVS[11].y) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(-(intBitsToFloat(R4i.y)) + -(intBitsToFloat(uf_remappedVS[11].x))); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].x)) + intBitsToFloat(uf_remappedVS[11].y)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R5i.z; +R5i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +predResult = (intBitsToFloat(uf_remappedVS[11].w) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(intBitsToFloat(R4i.y) + intBitsToFloat(uf_remappedVS[11].w)); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].z)) + intBitsToFloat(uf_remappedVS[11].w)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R5i.z; +R5i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = ((0.0 >= intBitsToFloat(uf_remappedVS[0].w))?int(0xFFFFFFFF):int(0x0)); +R3i.w = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(R5i.z)); +// 1 +backupReg0i = R0i.z; +backupReg1i = R0i.w; +R0i.x = ((PV0i.x == 0)?(R2i.x):(0x3f800000)); +R0i.y = ((PV0i.x == 0)?(R8i.y):(0x3f800000)); +R0i.z = ((PV0i.x == 0)?(backupReg0i):(0x3f800000)); +R0i.w = ((PV0i.x == 0)?(backupReg1i):(0x3f800000)); +} +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R0i.x)*(origRatio / newRatio), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R3i.x), intBitsToFloat(R3i.y), intBitsToFloat(R3i.z), intBitsToFloat(R3i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem2 = vec4(intBitsToFloat(R7i.x), intBitsToFloat(R7i.y), intBitsToFloat(R7i.z), intBitsToFloat(R7i.w)); +// export +passParameterSem3 = vec4(intBitsToFloat(R9i.x), intBitsToFloat(R9i.y), intBitsToFloat(R9i.z), intBitsToFloat(R9i.w)); +if( activeMaskStackC[1] == true ) { +// 0 +} +} diff --git a/Enhancement/XenobladeX_219_GUI/28620f4f4753fb97_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/28620f4f4753fb97_0000000000000000_vs.txt new file mode 100644 index 00000000..33d8a456 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/28620f4f4753fb97_0000000000000000_vs.txt @@ -0,0 +1,163 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 28620f4f4753fb97 +// selectio position +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +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() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = 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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R126i.x = floatBitsToInt(float(PS0i)); +PS1i = R126i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[18].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[18].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[18].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[18].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[15].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[15].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[15].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[15].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[14].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[14].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[14].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[14].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[13].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[13].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[13].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[13].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[12].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[12].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[12].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[12].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +R0i.xyz = ivec3(uf_uniformRegisterVS[ARi.x+4].x,uf_uniformRegisterVS[ARi.x+4].y,uf_uniformRegisterVS[ARi.x+4].z); +R0i.w = uf_uniformRegisterVS[ARi.x+4].w; +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R1i.x)*(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/3e12e7b9d981b915_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/3e12e7b9d981b915_0000000000000000_vs.txt new file mode 100644 index 00000000..d8d07e48 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/3e12e7b9d981b915_0000000000000000_vs.txt @@ -0,0 +1,188 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 3e12e7b9d981b915 +// box canvas ingame *dumped* +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R126i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].w) * 1.0); +R125i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].z) * 1.0); +R125i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].y) * 1.0); +R125i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].x) * 1.0); +R125i.x = floatBitsToInt(float(PS0i)); +PS1i = R125i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[20].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +backupReg0i = R125i.z; +backupReg1i = R125i.w; +R125i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(backupReg0i))); +R125i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(backupReg1i))); +// 18 +backupReg0i = R126i.x; +backupReg1i = R125i.y; +R126i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(backupReg1i))); +// 19 +R0i.xyz = ivec3(uf_uniformRegisterVS[ARi.x+4].x,uf_uniformRegisterVS[ARi.x+4].y,uf_uniformRegisterVS[ARi.x+4].z); +R0i.w = uf_uniformRegisterVS[ARi.x+4].w; +// 20 +R2i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(R125i.w))); +R2i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(R125i.z))); +// 21 +R2i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(R125i.y))); +R2i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(R126i.x))); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R1i.x)*(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/46bdcbf27127ae3b_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/46bdcbf27127ae3b_0000000000000000_vs.txt new file mode 100644 index 00000000..dc2e5bfd --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/46bdcbf27127ae3b_0000000000000000_vs.txt @@ -0,0 +1,132 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 46bdcbf27127ae3b +// depth, scary *dumped* +uniform ivec4 uf_remappedVS[11]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +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() +{ +vec4 R0f = vec4(0.0); +vec4 R1f = vec4(0.0); +vec4 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +PV0f.x = intBitsToFloat(uf_remappedVS[0].w) * 1.0; +PV0f.y = intBitsToFloat(uf_remappedVS[0].z) * 1.0; +PV0f.z = intBitsToFloat(uf_remappedVS[0].y) * 1.0; +PV0f.w = intBitsToFloat(uf_remappedVS[0].x) * 1.0; +// 1 +R123f.x = (R1f.y * intBitsToFloat(uf_remappedVS[1].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R1f.y * intBitsToFloat(uf_remappedVS[1].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R1f.y * intBitsToFloat(uf_remappedVS[1].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R1f.y * intBitsToFloat(uf_remappedVS[1].x) + PV0f.w); +PV1f.w = R123f.w; +// 2 +R123f.x = (R1f.x * intBitsToFloat(uf_remappedVS[2].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R1f.x * intBitsToFloat(uf_remappedVS[2].z) + PV1f.y); +R127f.z = (R1f.x * intBitsToFloat(uf_remappedVS[2].y) + PV1f.z); +R127f.w = (R1f.x * intBitsToFloat(uf_remappedVS[2].x) + PV1f.w); +// 3 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[3].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[3].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[3].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[3].x); +// 4 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[4].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[4].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[4].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[4].x) + PV1f.w); +PV0f.w = R123f.w; +// 5 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[5].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[5].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[5].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[5].x) + PV0f.w); +PV1f.w = R123f.w; +// 6 +backupReg0f = R127f.w; +R123f.x = (R127f.w * intBitsToFloat(uf_remappedVS[6].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R127f.w * intBitsToFloat(uf_remappedVS[6].z) + PV1f.y); +R127f.z = (R127f.w * intBitsToFloat(uf_remappedVS[6].y) + PV1f.z); +R127f.w = (backupReg0f * intBitsToFloat(uf_remappedVS[6].x) + PV1f.w); +// 7 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[7].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[7].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[7].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[7].x); +// 8 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[8].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[8].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[8].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[8].x) + PV1f.w); +PV0f.w = R123f.w; +// 9 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[9].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[9].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[9].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[9].x) + PV0f.w); +PV1f.w = R123f.w; +// 10 +R1f.x = (R127f.w * intBitsToFloat(uf_remappedVS[10].x) + PV1f.w); +R1f.y = (R127f.w * intBitsToFloat(uf_remappedVS[10].y) + PV1f.z); +R1f.z = (R127f.w * intBitsToFloat(uf_remappedVS[10].z) + PV1f.y); +R1f.w = (R127f.w * intBitsToFloat(uf_remappedVS[10].w) + PV1f.x); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(R1f.x*(origRatio / newRatio), R1f.y, R1f.z, R1f.w); +// export +// skipped export to semanticId 255 +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/538fc98d957aaa7c_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/538fc98d957aaa7c_0000000000000000_vs.txt new file mode 100644 index 00000000..92c5ce82 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/538fc98d957aaa7c_0000000000000000_vs.txt @@ -0,0 +1,188 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 538fc98d957aaa7c +// box canvas +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R126i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].w) * 1.0); +R125i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].z) * 1.0); +R125i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].y) * 1.0); +R125i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].x) * 1.0); +R125i.x = floatBitsToInt(float(PS0i)); +PS1i = R125i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[20].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +backupReg0i = R125i.z; +backupReg1i = R125i.w; +R125i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(backupReg0i))); +R125i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(backupReg1i))); +// 18 +backupReg0i = R126i.x; +backupReg1i = R125i.y; +R126i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(backupReg1i))); +// 19 +R0i.xyz = ivec3(uf_uniformRegisterVS[ARi.x+4].x,uf_uniformRegisterVS[ARi.x+4].y,uf_uniformRegisterVS[ARi.x+4].z); +R0i.w = uf_uniformRegisterVS[ARi.x+4].w; +// 20 +R2i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(R125i.w))); +R2i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(R125i.z))); +// 21 +R2i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(R125i.y))); +R2i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(R126i.x))); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R1i.x) *(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/8ff56afdf1a2f837_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/8ff56afdf1a2f837_0000000000000000_vs.txt new file mode 100644 index 00000000..9793e8e3 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/8ff56afdf1a2f837_0000000000000000_vs.txt @@ -0,0 +1,171 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 8ff56afdf1a2f837 +// text *dumped* +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R126i = ivec4(0); +ivec4 R127i = ivec4(0); +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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R2i.z = 0; +R2i.w = floatBitsToInt(1.0); +R126i.x = floatBitsToInt(float(PS0i)); +PS1i = R126i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[22].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[22].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +R0i.w = uf_uniformRegisterVS[ARi.x+8].w; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[21].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[21].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[22].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[22].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[20].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[20].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[21].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[21].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[20].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[20].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +R0i.xyz = ivec3(uf_uniformRegisterVS[ARi.x+4].x,uf_uniformRegisterVS[ARi.x+4].y,uf_uniformRegisterVS[ARi.x+4].z); +// 18 +R2i.x = uf_uniformRegisterVS[ARi.x+12].x; +R2i.y = uf_uniformRegisterVS[ARi.x+12].y; +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +gl_Position = vec4(intBitsToFloat(R1i.x)*(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/9bc5e526132c9534_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/9bc5e526132c9534_0000000000000000_vs.txt new file mode 100644 index 00000000..bcc72828 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/9bc5e526132c9534_0000000000000000_vs.txt @@ -0,0 +1,138 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 9bc5e526132c9534 +// selection fill *dumped* +uniform ivec4 uf_remappedVS[11]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +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); +vec4 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem1.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder = attrDataSem0; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(int(attrDecoder.w))); +// 0 +PV0f.x = intBitsToFloat(uf_remappedVS[0].w) * 1.0; +PV0f.y = intBitsToFloat(uf_remappedVS[0].z) * 1.0; +PV0f.z = intBitsToFloat(uf_remappedVS[0].y) * 1.0; +PV0f.w = intBitsToFloat(uf_remappedVS[0].x) * 1.0; +// 1 +R123f.x = (R2f.y * intBitsToFloat(uf_remappedVS[1].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R2f.y * intBitsToFloat(uf_remappedVS[1].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R2f.y * intBitsToFloat(uf_remappedVS[1].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R2f.y * intBitsToFloat(uf_remappedVS[1].x) + PV0f.w); +PV1f.w = R123f.w; +// 2 +R123f.x = (R2f.x * intBitsToFloat(uf_remappedVS[2].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R2f.x * intBitsToFloat(uf_remappedVS[2].z) + PV1f.y); +R127f.z = (R2f.x * intBitsToFloat(uf_remappedVS[2].y) + PV1f.z); +R127f.w = (R2f.x * intBitsToFloat(uf_remappedVS[2].x) + PV1f.w); +// 3 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[3].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[3].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[3].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[3].x); +// 4 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[4].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[4].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[4].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[4].x) + PV1f.w); +PV0f.w = R123f.w; +// 5 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[5].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[5].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[5].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[5].x) + PV0f.w); +PV1f.w = R123f.w; +// 6 +backupReg0f = R127f.w; +R123f.x = (R127f.w * intBitsToFloat(uf_remappedVS[6].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R127f.w * intBitsToFloat(uf_remappedVS[6].z) + PV1f.y); +R127f.z = (R127f.w * intBitsToFloat(uf_remappedVS[6].y) + PV1f.z); +R127f.w = (backupReg0f * intBitsToFloat(uf_remappedVS[6].x) + PV1f.w); +// 7 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[7].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[7].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[7].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[7].x); +// 8 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[8].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[8].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[8].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[8].x) + PV1f.w); +PV0f.w = R123f.w; +// 9 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[9].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[9].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[9].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[9].x) + PV0f.w); +PV1f.w = R123f.w; +// 10 +R2f.x = (R127f.w * intBitsToFloat(uf_remappedVS[10].x) + PV1f.w); +R2f.y = (R127f.w * intBitsToFloat(uf_remappedVS[10].y) + PV1f.z); +R2f.z = (R127f.w * intBitsToFloat(uf_remappedVS[10].z) + PV1f.y); +R2f.w = (R127f.w * intBitsToFloat(uf_remappedVS[10].w) + PV1f.x); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(R2f.x*(origRatio / newRatio), R2f.y, R2f.z, R2f.w); +// export +passParameterSem0 = vec4(R1f.x, R1f.y, R1f.z, R1f.w); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/9f390af3897e9112_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/9f390af3897e9112_0000000000000000_vs.txt new file mode 100644 index 00000000..2c2ef647 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/9f390af3897e9112_0000000000000000_vs.txt @@ -0,0 +1,181 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader 9f390af3897e9112 +//active selection +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +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() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[23].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R126i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].w) * 1.0); +R125i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].z) * 1.0); +R125i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].y) * 1.0); +R125i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[15].x) * 1.0); +R125i.x = floatBitsToInt(float(PS0i)); +PS1i = R125i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[22].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[22].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[21].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[21].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[22].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].z) * intBitsToFloat(uf_uniformRegisterVS[22].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[20].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[20].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[21].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].y) * intBitsToFloat(uf_uniformRegisterVS[21].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[19].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[20].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+4].x) * intBitsToFloat(uf_uniformRegisterVS[20].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[18].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +backupReg0i = R125i.z; +backupReg1i = R125i.w; +R125i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].y) + intBitsToFloat(backupReg0i))); +R125i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].x) + intBitsToFloat(backupReg1i))); +// 18 +backupReg0i = R126i.x; +backupReg1i = R125i.y; +R126i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].w) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[13].z) + intBitsToFloat(backupReg1i))); +// 19 +R0i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].x) + intBitsToFloat(R125i.w))); +R0i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].y) + intBitsToFloat(R125i.z))); +// 20 +R0i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].z) + intBitsToFloat(R125i.y))); +R0i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[12].w) + intBitsToFloat(R126i.x))); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; + +gl_Position = vec4(intBitsToFloat(R1i.x)*(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/b679b0945943e505_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/b679b0945943e505_0000000000000000_vs.txt new file mode 100644 index 00000000..75bfb2db --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/b679b0945943e505_0000000000000000_vs.txt @@ -0,0 +1,163 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader b679b0945943e505 +// selection box frame *dumped* +uniform ivec4 uf_remappedVS[14]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +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); +vec4 R123f = vec4(0.0); +vec4 R127f = vec4(0.0); +uvec4 attrDecoder; +float backupReg0f, backupReg1f, backupReg2f, backupReg3f, backupReg4f; +vec4 PV0f = vec4(0.0), PV1f = vec4(0.0); +float PS0f = 0.0, PS1f = 0.0; +vec4 tempf = vec4(0.0); +float tempResultf; +int tempResulti; +ivec4 ARi = ivec4(0); +bool predResult = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0f = floatBitsToInt(ivec4(gl_VertexID, 0, 0, gl_InstanceID)); +attrDecoder.xyz = attrDataSem0.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R1f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(int(attrDecoder.z)), intBitsToFloat(floatBitsToInt(1.0))); +attrDecoder.xy = attrDataSem1.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R2f = vec4(intBitsToFloat(int(attrDecoder.x)), intBitsToFloat(int(attrDecoder.y)), intBitsToFloat(floatBitsToInt(0.0)), intBitsToFloat(floatBitsToInt(1.0))); +// 0 +PV0f.x = intBitsToFloat(uf_remappedVS[0].w) * 1.0; +PV0f.y = intBitsToFloat(uf_remappedVS[0].z) * 1.0; +PV0f.z = intBitsToFloat(uf_remappedVS[0].y) * 1.0; +PV0f.w = intBitsToFloat(uf_remappedVS[0].x) * 1.0; +// 1 +R123f.x = (R1f.y * intBitsToFloat(uf_remappedVS[1].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R1f.y * intBitsToFloat(uf_remappedVS[1].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R1f.y * intBitsToFloat(uf_remappedVS[1].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R1f.y * intBitsToFloat(uf_remappedVS[1].x) + PV0f.w); +PV1f.w = R123f.w; +// 2 +R123f.x = (R1f.x * intBitsToFloat(uf_remappedVS[2].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R1f.x * intBitsToFloat(uf_remappedVS[2].z) + PV1f.y); +R127f.z = (R1f.x * intBitsToFloat(uf_remappedVS[2].y) + PV1f.z); +R127f.w = (R1f.x * intBitsToFloat(uf_remappedVS[2].x) + PV1f.w); +// 3 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[3].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[3].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[3].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[3].x); +// 4 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[4].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[4].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[4].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[4].x) + PV1f.w); +PV0f.w = R123f.w; +// 5 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[5].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[5].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[5].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[5].x) + PV0f.w); +PV1f.w = R123f.w; +// 6 +backupReg0f = R127f.w; +R123f.x = (R127f.w * intBitsToFloat(uf_remappedVS[6].w) + PV1f.x); +PV0f.x = R123f.x; +R127f.y = (R127f.w * intBitsToFloat(uf_remappedVS[6].z) + PV1f.y); +R127f.z = (R127f.w * intBitsToFloat(uf_remappedVS[6].y) + PV1f.z); +R127f.w = (backupReg0f * intBitsToFloat(uf_remappedVS[6].x) + PV1f.w); +// 7 +PV1f.x = PV0f.x * intBitsToFloat(uf_remappedVS[7].w); +PV1f.y = PV0f.x * intBitsToFloat(uf_remappedVS[7].z); +PV1f.z = PV0f.x * intBitsToFloat(uf_remappedVS[7].y); +PV1f.w = PV0f.x * intBitsToFloat(uf_remappedVS[7].x); +// 8 +R123f.x = (R127f.y * intBitsToFloat(uf_remappedVS[8].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R127f.y * intBitsToFloat(uf_remappedVS[8].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R127f.y * intBitsToFloat(uf_remappedVS[8].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R127f.y * intBitsToFloat(uf_remappedVS[8].x) + PV1f.w); +PV0f.w = R123f.w; +// 9 +R123f.x = (R127f.z * intBitsToFloat(uf_remappedVS[9].w) + PV0f.x); +PV1f.x = R123f.x; +R123f.y = (R127f.z * intBitsToFloat(uf_remappedVS[9].z) + PV0f.y); +PV1f.y = R123f.y; +R123f.z = (R127f.z * intBitsToFloat(uf_remappedVS[9].y) + PV0f.z); +PV1f.z = R123f.z; +R123f.w = (R127f.z * intBitsToFloat(uf_remappedVS[9].x) + PV0f.w); +PV1f.w = R123f.w; +// 10 +R1f.x = (R127f.w * intBitsToFloat(uf_remappedVS[10].x) + PV1f.w); +R1f.y = (R127f.w * intBitsToFloat(uf_remappedVS[10].y) + PV1f.z); +R1f.z = (R127f.w * intBitsToFloat(uf_remappedVS[10].z) + PV1f.y); +R1f.w = (R127f.w * intBitsToFloat(uf_remappedVS[10].w) + PV1f.x); +// 11 +PV1f.x = intBitsToFloat(uf_remappedVS[11].w) * 1.0; +PV1f.y = intBitsToFloat(uf_remappedVS[11].z) * 1.0; +PV1f.z = intBitsToFloat(uf_remappedVS[11].y) * 1.0; +PV1f.w = intBitsToFloat(uf_remappedVS[11].x) * 1.0; +// 12 +R123f.x = (R2f.y * intBitsToFloat(uf_remappedVS[12].w) + PV1f.x); +PV0f.x = R123f.x; +R123f.y = (R2f.y * intBitsToFloat(uf_remappedVS[12].z) + PV1f.y); +PV0f.y = R123f.y; +R123f.z = (R2f.y * intBitsToFloat(uf_remappedVS[12].y) + PV1f.z); +PV0f.z = R123f.z; +R123f.w = (R2f.y * intBitsToFloat(uf_remappedVS[12].x) + PV1f.w); +PV0f.w = R123f.w; +// 13 +backupReg0f = R2f.x; +backupReg0f = R2f.x; +backupReg0f = R2f.x; +backupReg0f = R2f.x; +R2f.x = (backupReg0f * intBitsToFloat(uf_remappedVS[13].x) + PV0f.w); +R2f.y = (backupReg0f * intBitsToFloat(uf_remappedVS[13].y) + PV0f.z); +R2f.z = (backupReg0f * intBitsToFloat(uf_remappedVS[13].z) + PV0f.y); +R2f.w = (backupReg0f * intBitsToFloat(uf_remappedVS[13].w) + PV0f.x); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(R1f.x*(origRatio / newRatio), R1f.y, R1f.z, R1f.w); +// export +passParameterSem0 = vec4(R2f.x, R2f.y, R2f.z, R2f.w); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/d6e8f178a5b828f0_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/d6e8f178a5b828f0_0000000000000000_vs.txt new file mode 100644 index 00000000..2c226041 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/d6e8f178a5b828f0_0000000000000000_vs.txt @@ -0,0 +1,188 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader d6e8f178a5b828f0 +// bg boxes +uniform ivec4 uf_uniformRegisterVS[256]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +uniform float uf_alphaTestRef; +layout(location = 0) in uvec4 attrDataSem0; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +ivec4 R0i = ivec4(0); +ivec4 R1i = ivec4(0); +ivec4 R2i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +// 0 +R127i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].w) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].y) * 1.0); +R127i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[27].x) * 1.0); +PS0i = int(intBitsToFloat(R1i.z)); +// 1 +R126i.x = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].w) * 1.0); +R125i.y = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].z) * 1.0); +R125i.z = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].y) * 1.0); +R125i.w = floatBitsToInt(intBitsToFloat(uf_uniformRegisterVS[19].x) * 1.0); +R125i.x = floatBitsToInt(float(PS0i)); +PS1i = R125i.x; +// 2 +tempResultf = intBitsToFloat(PS1i); +tempResultf = floor(tempResultf); +tempResultf = clamp(tempResultf, -256.0, 255.0); +ARi.x = int(tempResultf); +PV0i.x = floatBitsToInt(tempResultf); +// 3 +R123i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].w) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].z) + intBitsToFloat(R127i.y))); +PV1i.y = R123i.y; +// 4 +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].w) + intBitsToFloat(PV1i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].z) + intBitsToFloat(PV1i.y))); +// 5 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].z) * intBitsToFloat(uf_uniformRegisterVS[26].x) + intBitsToFloat(backupReg1i))); +// 6 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].w) + intBitsToFloat(backupReg0i))); +R126i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].z) + intBitsToFloat(R127i.y))); +// 7 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].y) * intBitsToFloat(uf_uniformRegisterVS[25].x) + intBitsToFloat(backupReg1i))); +// 8 +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].w)); +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].y)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[23].x)); +// 9 +backupReg0i = R127i.z; +backupReg1i = R127i.w; +R127i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].y) + intBitsToFloat(backupReg0i))); +R127i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+8].x) * intBitsToFloat(uf_uniformRegisterVS[24].x) + intBitsToFloat(backupReg1i))); +// 10 +R123i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].w) + intBitsToFloat(R127i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].z) + intBitsToFloat(R127i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].y) + intBitsToFloat(R126i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_uniformRegisterVS[22].x) + intBitsToFloat(R126i.w))); +PV0i.w = R123i.w; +// 11 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[21].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 12 +backupReg0i = R127i.w; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].z) + intBitsToFloat(PV1i.y))); +R127i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[20].y) + intBitsToFloat(PV1i.z))); +R127i.w = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_uniformRegisterVS[20].x) + intBitsToFloat(PV1i.w))); +// 13 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].z)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_uniformRegisterVS[3].x)); +// 14 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].z) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].y) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_uniformRegisterVS[2].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].z) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].y) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_uniformRegisterVS[1].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +// 16 +R1i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].x) + intBitsToFloat(PV1i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].y) + intBitsToFloat(PV1i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].z) + intBitsToFloat(PV1i.y))); +R1i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_uniformRegisterVS[0].w) + intBitsToFloat(PV1i.x))); +// 17 +backupReg0i = R125i.z; +backupReg1i = R125i.w; +R125i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].y) + intBitsToFloat(backupReg0i))); +R125i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].x) + intBitsToFloat(backupReg1i))); +// 18 +backupReg0i = R126i.x; +backupReg1i = R125i.y; +R126i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].w) + intBitsToFloat(backupReg0i))); +R125i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].y) * intBitsToFloat(uf_uniformRegisterVS[17].z) + intBitsToFloat(backupReg1i))); +// 19 +R0i.xyz = ivec3(uf_uniformRegisterVS[ARi.x+4].x,uf_uniformRegisterVS[ARi.x+4].y,uf_uniformRegisterVS[ARi.x+4].z); +R0i.w = uf_uniformRegisterVS[ARi.x+4].w; +// 20 +R2i.x = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].x) + intBitsToFloat(R125i.w))); +R2i.y = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].y) + intBitsToFloat(R125i.z))); +// 21 +R2i.z = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].z) + intBitsToFloat(R125i.y))); +R2i.w = floatBitsToInt((intBitsToFloat(uf_uniformRegisterVS[ARi.x+12].x) * intBitsToFloat(uf_uniformRegisterVS[16].w) + intBitsToFloat(R126i.x))); +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R1i.x)*(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/d7074f19f5ca3b20_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/d7074f19f5ca3b20_0000000000000000_vs.txt new file mode 100644 index 00000000..2356d180 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/d7074f19f5ca3b20_0000000000000000_vs.txt @@ -0,0 +1,290 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader d7074f19f5ca3b20 +//tower counter +uniform ivec4 uf_remappedVS[14]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +layout(location = 3) in uvec4 attrDataSem3; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 1) out vec4 passParameterSem1; +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() +{ +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 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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.xy = attrDataSem0.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xyz = attrDataSem1.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 = attrDataSem2; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R3i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xy = attrDataSem3.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R4i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +// 0 +R123i.x = floatBitsToInt((intBitsToFloat(R3i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R3i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.y = R123i.y; +R125i.z = 0; +R126i.w = 0; +R126i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(R4i.x)); +PS0i = R126i.x; +// 1 +PV1i.x = floatBitsToInt(fract(intBitsToFloat(PV0i.y))); +PV1i.y = floatBitsToInt(fract(intBitsToFloat(PV0i.x))); +R0i.z = floatBitsToInt(intBitsToFloat(R1i.y) * intBitsToFloat(R4i.y)); +R125i.w = 0x3f800000; +R125i.x = ((0.0 > intBitsToFloat(R3i.w))?int(0xFFFFFFFF):int(0x0)); +PS1i = R125i.x; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.x = R123i.x; +R124i.y = 0x3f800000; +R1i.z = 0; +R123i.w = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.w = R123i.w; +R3i.z = 0; +PS0i = R3i.z; +// 3 +R127i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3e22f983)); +R4i.y = floatBitsToInt(-(intBitsToFloat(R1i.y)) + 0.5); +R127i.z = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(0x3e22f983)); +PV1i.z = R127i.z; +PV1i.w = floatBitsToInt(intBitsToFloat(R1i.x) + 0.5); +// 4 +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(0x3d579436)); +PS0i = floatBitsToInt(sin((intBitsToFloat(PV1i.z))/0.1591549367)); +// 5 +R4i.x = floatBitsToInt(intBitsToFloat(R3i.w) + intBitsToFloat(PV0i.z)); +R124i.z = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +R127i.w = PS0i; +PS1i = floatBitsToInt(cos((intBitsToFloat(R127i.z))/0.1591549367)); +// 6 +R126i.y = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +R127i.z = PS1i; +PV0i.z = R127i.z; +PS0i = floatBitsToInt(sin((intBitsToFloat(R127i.x))/0.1591549367)); +// 7 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +R127i.y = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +R126i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(PS0i)); +PS1i = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +// 8 +backupReg0i = R127i.z; +PV0i.x = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +R125i.y = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS1i)); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS1i)); +// 9 +backupReg0i = R126i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.w),intBitsToFloat(R0i.z),intBitsToFloat(R126i.x),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(R127i.y),intBitsToFloat(backupReg0i),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.z = tempi.x; +// 10 +backupReg0i = R126i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R125i.z),intBitsToFloat(backupReg0i),intBitsToFloat(R124i.z),-0.0),vec4(intBitsToFloat(R126i.w),intBitsToFloat(R0i.z),intBitsToFloat(R126i.x),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.y = tempi.x; +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.w),intBitsToFloat(R0i.z),intBitsToFloat(R126i.x),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R125i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.x = floatBitsToInt(intBitsToFloat(R2i.x) + intBitsToFloat(R126i.z)); +PS1i = R127i.x; +// 12 +backupReg0i = R126i.y; +R126i.y = floatBitsToInt(intBitsToFloat(R2i.y) + intBitsToFloat(backupReg0i)); +PV0i.y = R126i.y; +R126i.z = floatBitsToInt(intBitsToFloat(R2i.z) + intBitsToFloat(PV1i.x)); +PV0i.z = R126i.z; +// 13 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),intBitsToFloat(R125i.w)),vec4(intBitsToFloat(uf_remappedVS[0].x),intBitsToFloat(uf_remappedVS[0].y),intBitsToFloat(uf_remappedVS[0].z),intBitsToFloat(uf_remappedVS[0].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +// 14 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),intBitsToFloat(R125i.w)),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),intBitsToFloat(uf_remappedVS[1].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.z = ((R125i.x == 0)?(PV1i.x):(0)); +PS0i = R127i.z; +// 15 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),intBitsToFloat(R125i.w)),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R1i.x = ((R125i.x == 0)?(PV0i.x):(R1i.z)); +PS1i = R1i.x; +// 16 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),intBitsToFloat(R125i.w)),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R1i.y = ((R125i.x == 0)?(PV1i.x):(R3i.z)); +PS0i = R1i.y; +// 17 +PV1i.x = floatBitsToInt(intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[4].w)); +R1i.z = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(0x3f7fff58)); +R1i.w = ((R125i.x == 0)?(PV0i.x):(R124i.y)); +R125i.x = floatBitsToInt(intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[5].w)); +PS1i = R125i.x; +// 18 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),intBitsToFloat(PV1i.x)),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),1.0))); +PV0i.x = R126i.x; +PV0i.y = R126i.x; +PV0i.z = R126i.x; +PV0i.w = R126i.x; +// 19 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R126i.y),intBitsToFloat(R126i.z),intBitsToFloat(R125i.x)),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),1.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R124i.y = tempi.x; +// 20 +backupReg0i = R126i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R126i.y),intBitsToFloat(backupReg0i),intBitsToFloat(R125i.w)),vec4(intBitsToFloat(uf_remappedVS[6].x),intBitsToFloat(uf_remappedVS[6].y),intBitsToFloat(uf_remappedVS[6].z),intBitsToFloat(uf_remappedVS[6].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.z = tempi.x; +// 21 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(R124i.y),intBitsToFloat(PV0i.x),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(R124i.y),intBitsToFloat(PV0i.x),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +PS1i = floatBitsToInt(-(intBitsToFloat(PV0i.x)) + -(intBitsToFloat(uf_remappedVS[7].x))); +// 22 +PV0i.z = floatBitsToInt(intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[7].y)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV1i.x)); +PS0i = floatBitsToInt(tempResultf); +// 23 +backupReg0i = R126i.z; +R0i.x = floatBitsToInt(intBitsToFloat(R126i.x) * intBitsToFloat(PS0i)); +PV1i.x = R0i.x; +R2i.y = floatBitsToInt(intBitsToFloat(R124i.y) * intBitsToFloat(PS0i)); +PV1i.y = R2i.y; +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS0i)); +PV1i.z = R126i.z; +PV1i.w = floatBitsToInt(max(intBitsToFloat(PV0i.z), 0.0)); +// 24 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[8].x),intBitsToFloat(uf_remappedVS[8].y),intBitsToFloat(uf_remappedVS[8].z),-0.0),vec4(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(PV1i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +tempResultf = log2(intBitsToFloat(PV1i.w)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0i = floatBitsToInt(tempResultf); +// 25 +R3i.x = floatBitsToInt(intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[7].z)); +R3i.w = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +R2i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].z) * intBitsToFloat(R126i.z)); +PS1i = R2i.x; +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R1i.x) *(origRatio / newRatio), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R4i.x), intBitsToFloat(R4i.y), intBitsToFloat(R4i.z), intBitsToFloat(R4i.z)); +// 0 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[9].y) * intBitsToFloat(R2i.y) + intBitsToFloat(R2i.x))); +PV0i.x = R123i.x; +PV0i.z = floatBitsToInt(-(intBitsToFloat(R3i.w)) + 1.0); +PS0i = floatBitsToInt(exp2(intBitsToFloat(R3i.x))); +// 1 +PV1i.y = floatBitsToInt(min(intBitsToFloat(PS0i), 1.0)); +R123i.w = floatBitsToInt((intBitsToFloat(uf_remappedVS[9].x) * intBitsToFloat(R0i.x) + intBitsToFloat(PV0i.x))); +R123i.w = clampFI32(R123i.w); +PV1i.w = R123i.w; +tempResultf = log2(intBitsToFloat(PV0i.z)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1i = floatBitsToInt(tempResultf); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[10].w)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[7].w)); +tempResultf = log2(intBitsToFloat(PV1i.w)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0i = floatBitsToInt(tempResultf); +// 3 +PV1i.y = floatBitsToInt(intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[11].w)); +R0i.w = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[12].w)); +R125i.w = floatBitsToInt(exp2(intBitsToFloat(PV0i.x))); +PS1i = R125i.w; +// 4 +R124i.y = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[10].y) + intBitsToFloat(uf_remappedVS[13].y))); +R126i.z = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[10].x) + intBitsToFloat(uf_remappedVS[13].x))); +R126i.x = floatBitsToInt(exp2(intBitsToFloat(PV1i.y))); +PS0i = R126i.x; +// 5 +R123i.x = floatBitsToInt((intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[10].z) + intBitsToFloat(uf_remappedVS[13].z))); +PV1i.x = R123i.x; +// 6 +R0i.x = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[11].x) + intBitsToFloat(R126i.z))); +R0i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[11].y) + intBitsToFloat(R124i.y))); +R0i.z = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[11].z) + intBitsToFloat(PV1i.x))); +passParameterSem0 = vec4(intBitsToFloat(R0i.x) *(origRatio / newRatio), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// 0 +} diff --git a/Enhancement/XenobladeX_219_GUI/e082c1f638f8e81e_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/e082c1f638f8e81e_0000000000000000_vs.txt new file mode 100644 index 00000000..74d35dd6 --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/e082c1f638f8e81e_0000000000000000_vs.txt @@ -0,0 +1,1366 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader e082c1f638f8e81e +// transport flame *dumped* +uniform ivec4 uf_remappedVS[27]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +layout(location = 3) in uvec4 attrDataSem3; +layout(location = 4) in uvec4 attrDataSem4; +layout(location = 5) in uvec4 attrDataSem5; +layout(location = 6) in uvec4 attrDataSem6; +layout(location = 7) in uvec4 attrDataSem7; +layout(location = 8) in uvec4 attrDataSem8; +layout(location = 9) in uvec4 attrDataSem9; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 1) out vec4 passParameterSem1; +layout(location = 2) out vec4 passParameterSem2; +layout(location = 3) out vec4 passParameterSem3; +int clampFI32(int v) +{ +if( v == 0x7FFFFFFF ) + return floatBitsToInt(1.0); +else if( v == 0xFFFFFFFF ) + return floatBitsToInt(0.0); +return floatBitsToInt(clamp(intBitsToFloat(v), 0.0, 1.0)); +} +float mul_nonIEEE(float a, float b){ return min(a*b,min(abs(a)*3.40282347E+38F,abs(b)*3.40282347E+38F)); } +void main() +{ +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 R11i = ivec4(0); +ivec4 R12i = ivec4(0); +ivec4 R13i = ivec4(0); +ivec4 R122i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +bool activeMaskStack[5]; +bool activeMaskStackC[6]; +activeMaskStack[0] = false; +activeMaskStack[1] = false; +activeMaskStack[2] = false; +activeMaskStack[3] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStackC[2] = false; +activeMaskStackC[3] = false; +activeMaskStackC[4] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = ivec4(gl_VertexID, 0, 0, gl_InstanceID); +attrDecoder.xy = attrDataSem0.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder = attrDataSem1; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R2i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem4; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R5i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem5; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R6i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xyz = attrDataSem6.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R7i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder.xyz = attrDataSem3.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R4i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder = attrDataSem7; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R8i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem8; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R9i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xy = attrDataSem9.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R10i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem2.xyzw)/255.0); +R3i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R125i.x = floatBitsToInt(max(intBitsToFloat(R4i.x), -(intBitsToFloat(R4i.x)))); +PV0i.x = R125i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R6i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.y = R123i.y; +R127i.z = floatBitsToInt(max(intBitsToFloat(R4i.y), -(intBitsToFloat(R4i.y)))); +PV0i.z = R127i.z; +R127i.w = R4i.z; +R127i.y = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 1 +R127i.x = floatBitsToInt(intBitsToFloat(R7i.x) * intBitsToFloat(PV0i.x)); +R123i.y = floatBitsToInt((intBitsToFloat(R6i.z) * intBitsToFloat(0x3e22f983) + 0.5)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[0].x) + -(0.5)); +PV1i.w = floatBitsToInt(fract(intBitsToFloat(PV0i.y))); +R126i.x = floatBitsToInt(intBitsToFloat(R7i.y) * intBitsToFloat(PV0i.z)); +PS1i = R126i.x; +// 2 +PV0i.x = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +R127i.y = floatBitsToInt(fract(intBitsToFloat(PV1i.y))); +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R7i.z) * intBitsToFloat(R127i.w)); +R124i.w = ((intBitsToFloat(PV1i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PS0i = R124i.w; +// 3 +PV1i.x = floatBitsToInt(-(intBitsToFloat(R127i.w)) + intBitsToFloat(PV0i.w)); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R127i.z)) + intBitsToFloat(R126i.x)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R125i.x)) + intBitsToFloat(R127i.x)); +R4i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3e22f983)); +R126i.z = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PS1i = R126i.z; +// 4 +backupReg0i = R127i.y; +backupReg1i = R125i.x; +R125i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.z))); +R127i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +R126i.y = R5i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) * 2.0); +PS0i = R126i.y; +// 5 +R127i.x = R5i.z; +R127i.x = floatBitsToInt(intBitsToFloat(R127i.x) * 2.0); +R125i.y = floatBitsToInt(intBitsToFloat(R4i.x) * intBitsToFloat(R7i.x)); +R125i.z = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R7i.y)); +R126i.w = R5i.y; +R126i.w = floatBitsToInt(intBitsToFloat(R126i.w) * 2.0); +R125i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(R7i.z)); +PS1i = R125i.w; +// 6 +PV0i.x = R7i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) / 2.0); +R0i.y = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(0x3e22f983)); +PV0i.z = 0; +PV0i.w = R7i.y; +PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) / 2.0); +R126i.z = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(0x3e22f983)); +PS0i = R126i.z; +// 7 +backupReg0i = R126i.w; +R0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R127i.w)); +R6i.y = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R127i.y)); +R6i.z = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R125i.x)); +R126i.w = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R126i.y)); +R124i.y = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(backupReg0i)); +PS1i = R124i.y; +// 8 +PV0i.x = R5i.y; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * 2.0); +R127i.y = R5i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R127i.y) * 2.0); +PV0i.z = R5i.z; +PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0); +R127i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R127i.x)); +R126i.y = R5i.w; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) * 2.0); +PS0i = R126i.y; +// 9 +backupReg0i = R125i.y; +R127i.x = floatBitsToInt(-(intBitsToFloat(R4i.z)) + intBitsToFloat(R125i.w)); +R125i.y = floatBitsToInt(-(intBitsToFloat(R4i.y)) + intBitsToFloat(R125i.z)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R4i.x)) + intBitsToFloat(backupReg0i)); +R0i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(PV0i.x)); +R125i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PV0i.z)); +PS1i = R125i.x; +// 10 +R124i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R0i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),0.0))); +PV0i.x = R124i.x; +PV0i.y = R124i.x; +PV0i.z = R124i.x; +PV0i.w = R124i.x; +R125i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.x))); +PS0i = R125i.w; +// 11 +backupReg0i = R127i.x; +backupReg1i = R125i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R126i.y)); +PV1i.x = R127i.x; +R125i.y = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.z))); +R125i.z = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.w) + intBitsToFloat(R4i.y))); +R124i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R126i.y)); +R4i.y = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w)); +PS1i = R4i.y; +// 12 +R126i.x = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R126i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R127i.y)); +R11i.w = floatBitsToInt(intBitsToFloat(R0i.w) + -(intBitsToFloat(PV1i.x))); +R0i.z = 0; +PS0i = R0i.z; +// 13 +R0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(R7i.x)); +PV1i.x = R0i.x; +R5i.y = floatBitsToInt(intBitsToFloat(R1i.y) * intBitsToFloat(R7i.y)); +PV1i.y = R5i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(R124i.y) + intBitsToFloat(R127i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R124i.y)); +R7i.x = 0; +PS1i = R7i.x; +// 14 +R0i.x = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R125i.w)); +R13i.y = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R125i.z)); +R13i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(R125i.y)); +R12i.w = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + 1.0); +R11i.y = 0; +PS0i = R11i.y; +// 15 +R4i.x = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(R127i.x)); +R7i.y = 0x3f800000; +R11i.z = 0; +R5i.w = floatBitsToInt(intBitsToFloat(R127i.z) + -(intBitsToFloat(R124i.w))); +R7i.w = floatBitsToInt(intBitsToFloat(R125i.x) + intBitsToFloat(R126i.x)); +PS1i = R7i.w; +// 16 +R11i.x = 0x3f800000; +R0i.z = floatBitsToInt(-(intBitsToFloat(R4i.y)) + 1.0); +R10i.w = floatBitsToInt(intBitsToFloat(R127i.z) + intBitsToFloat(R124i.w)); +R13i.w = floatBitsToInt(intBitsToFloat(R125i.x) + -(intBitsToFloat(R126i.x))); +PS0i = R13i.w; +// 17 +R1i.z = floatBitsToInt(-(intBitsToFloat(R127i.w)) + 1.0); +R7i.z = 0; +PS1i = R7i.z; +// 18 +R12i.z = 0; +PS0i = floatBitsToInt(sin((intBitsToFloat(R4i.w))/0.1591549367)); +// 19 +R127i.z = PS0i; +R0i.w = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +PS1i = floatBitsToInt(cos((intBitsToFloat(R4i.w))/0.1591549367)); +// 20 +R127i.w = PS1i; +R1i.w = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +PS0i = R1i.w; +// 21 +PS1i = floatBitsToInt(sin((intBitsToFloat(R0i.y))/0.1591549367)); +// 22 +backupReg0i = R0i.y; +R0i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +R4i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS1i)); +R2i.w = floatBitsToInt(-(intBitsToFloat(PS1i)) * 1.0); +PS0i = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +// 23 +R4i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS0i)); +R5i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +R4i.w = floatBitsToInt(intBitsToFloat(PS0i) * 1.0); +R127i.w = floatBitsToInt(sin((intBitsToFloat(R126i.z))/0.1591549367)); +PS1i = R127i.w; +// 24 +R5i.x = PS1i; +PS0i = floatBitsToInt(cos((intBitsToFloat(R126i.z))/0.1591549367)); +// 25 +R6i.x = PS0i; +R6i.y = floatBitsToInt(-(intBitsToFloat(R127i.w))); +R5i.y = PS0i; +PS1i = R5i.y; +// 26 +R10i.z = floatBitsToInt(sqrt(intBitsToFloat(R124i.x))); +PS0i = R10i.z; +// 27 +predResult = (intBitsToFloat(0xc0200000) > intBitsToFloat(R6i.w)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.xyz = ivec3(R4i.z,R0i.w,R5i.z); +PV0i.x = R127i.x; +PV0i.y = R127i.y; +PV0i.z = R127i.z; +R127i.w = 0; +R11i.x = uf_remappedVS[1].z; +PS0i = R11i.x; +// 1 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +// 2 +backupReg0i = R127i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +// 3 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R11i.y = uf_remappedVS[4].z; +PS1i = R11i.y; +// 4 +R11i.z = uf_remappedVS[5].z; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV1i.x)); +PS0i = floatBitsToInt(tempResultf); +// 5 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS0i)); +PV1i.x = R126i.x; +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS0i)); +PV1i.y = R127i.y; +// 6 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * -(intBitsToFloat(PV1i.x))); +PV0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PV1i.y)); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * -(intBitsToFloat(PV1i.x))); +// 7 +backupReg0i = R127i.y; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.z))); +R123i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.w))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.y))); +PV1i.w = R123i.w; +// 8 +R0i.x = PV1i.z; +PV0i.x = R0i.x; +R0i.y = PV1i.w; +PV0i.y = R0i.y; +R4i.x = PV1i.x; +PS0i = R4i.x; +// 9 +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV1i.x = R13i.x; +PV1i.y = R13i.x; +PV1i.z = R13i.x; +PV1i.w = R13i.x; +R4i.y = R127i.y; +PS1i = R4i.y; +// 10 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R13i.y = tempi.x; +// 11 +backupReg0i = R0i.x; +backupReg1i = R0i.y; +backupReg2i = R13i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(backupReg2i),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.z = tempi.x; +// 12 +R5i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV0i.x = R5i.x; +PV0i.y = R5i.x; +PV0i.z = R5i.x; +PV0i.w = R5i.x; +// 13 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.y = tempi.x; +// 14 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.z = tempi.x; +} +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 +predResult = (0.5 > intBitsToFloat(R6i.w)); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +R7i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),0.0))); +PV0i.x = R7i.x; +PV0i.y = R7i.x; +PV0i.z = R7i.x; +PV0i.w = R7i.x; +R4i.x = uf_remappedVS[1].x; +PS0i = R4i.x; +// 1 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.y = tempi.x; +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R11i.z)); +R4i.y = uf_remappedVS[1].y; +R4i.z = uf_remappedVS[1].z; +// 3 +R0i.xyz = ivec3(uf_remappedVS[4].x,uf_remappedVS[4].y,uf_remappedVS[4].z); +R122i.x = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(R6i.y) + intBitsToFloat(PV0i.x))); +PS1i = R122i.x; +// 4 +backupReg0i = R12i.z; +backupReg1i = R6i.x; +R12i.xyz = ivec3(uf_remappedVS[5].x,uf_remappedVS[5].y,uf_remappedVS[5].z); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R11i.z)); +R6i.x = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(backupReg1i) + intBitsToFloat(PS1i))); +PS0i = R6i.x; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(PV0i.w),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.y = tempi.x; +R1i.z = 0; +PS1i = R1i.z; +// 6 +predResult = (intBitsToFloat(0xbfc00000) > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = uf_remappedVS[1].w; +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].z) * 1.0); +R126i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[4].w))); +// 1 +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[1].y)); +R4i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * 0.0 + intBitsToFloat(PV0i.y))); +PS1i = R4i.z; +// 2 +R4i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.z))); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[1].y)); +// 3 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[4].y)); +R0i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * 0.0 + intBitsToFloat(R127i.z))); +// 4 +R0i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[4].y)); +// 5 +R126i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 6 +R126i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 7 +R4i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.y))); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[5].z) * 1.0); +// 8 +R12i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.y))); +R0i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w))); +R12i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * 0.0 + intBitsToFloat(PV1i.w))); +R12i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R126i.x))); +PS0i = R12i.y; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +activeMaskStack[4] = activeMaskStack[3]; +activeMaskStackC[5] = activeMaskStackC[4]; +// 0 +predResult = (0.0 > intBitsToFloat(R6i.w)); +activeMaskStack[4] = predResult; +activeMaskStackC[5] = predResult == true && activeMaskStackC[4] == true; +} +else { +activeMaskStack[4] = false; +activeMaskStackC[5] = false; +} +if( activeMaskStackC[5] == true ) { +// 0 +R4i.y = 0; +R4i.z = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[5].x))); +R0i.y = 0x3f800000; +PS0i = R0i.y; +// 1 +R12i.y = 0; +R0i.z = 0; +R12i.z = uf_remappedVS[1].x; +PS1i = R12i.z; +// 2 +R6i.z = 0; +// 3 +R7i.z = R10i.z; +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV0i.x = R13i.x; +PV0i.y = R13i.x; +PV0i.z = R13i.x; +PV0i.w = R13i.x; +R11i.x = R4i.z; +PS0i = R11i.x; +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.z; +backupReg1i = R0i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(backupReg1i),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.y = tempi.x; +R11i.y = backupReg1i; +PS1i = R11i.y; +// 2 +backupReg0i = R13i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(backupReg0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(R12i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R13i.z = tempi.x; +R11i.z = R12i.z; +PS0i = R11i.z; +// 3 +backupReg0i = R0i.z; +R5i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R1i.z),-0.0),vec4(intBitsToFloat(R4i.x),intBitsToFloat(R4i.y),intBitsToFloat(R4i.z),0.0))); +PV1i.x = R5i.x; +PV1i.y = R5i.x; +PV1i.z = R5i.x; +PV1i.w = R5i.x; +PS1i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(backupReg0i)); +// 4 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(PS1i),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),1.0,0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R5i.y = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R12i.z)); +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(PS0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R5i.z = tempi.x; +} +activeMaskStack[2] = activeMaskStack[2] == false; +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +predResult = (1.5 > intBitsToFloat(R6i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R13i.x = R13i.z; +R13i.z = R0i.x; +R12i.x = R12i.z; +PS0i = R12i.x; +// 1 +R12i.y = R1i.y; +R12i.z = R1i.x; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = ((intBitsToFloat(0x40600000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +PV0i.x = R127i.x; +R127i.y = ((intBitsToFloat(0x40200000) > intBitsToFloat(R6i.w))?int(0xFFFFFFFF):int(0x0)); +// 1 +R123i.x = ((PV0i.x == 0)?(R13i.y):(R0i.x)); +PV1i.x = R123i.x; +R123i.y = ((PV0i.x == 0)?(R13i.z):(R13i.z)); +PV1i.y = R123i.y; +R123i.z = ((PV0i.x == 0)?(R1i.y):(R1i.x)); +PV1i.z = R123i.z; +R123i.w = ((PV0i.x == 0)?(R0i.x):(R13i.y)); +PV1i.w = R123i.w; +R127i.z = ((PV0i.x == 0)?(R1i.x):(R1i.y)); +PS1i = R127i.z; +// 2 +backupReg0i = R13i.y; +R13i.x = ((R127i.y == 0)?(PV1i.x):(R0i.x)); +R13i.y = ((R127i.y == 0)?(PV1i.w):(R13i.z)); +R13i.z = ((R127i.y == 0)?(PV1i.y):(backupReg0i)); +R123i.w = ((R127i.x == 0)?(R12i.z):(R12i.z)); +PV0i.w = R123i.w; +R12i.x = ((R127i.y == 0)?(PV1i.z):(R1i.x)); +PS0i = R12i.x; +// 3 +R11i.x = ((R127i.y == 0)?(0):(R7i.x)); +R12i.y = ((R127i.y == 0)?(R127i.z):(R12i.z)); +R12i.z = ((R127i.y == 0)?(PV0i.w):(R1i.y)); +R11i.y = ((R127i.y == 0)?(0):(R7i.y)); +PS1i = R11i.y; +// 4 +backupReg0i = R11i.z; +R11i.z = ((R127i.y == 0)?(0x3f800000):(backupReg0i)); +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +backupReg0i = R0i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(R5i.x)); +PV0i.y = floatBitsToInt(intBitsToFloat(R5i.z) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R5i.x)); +PV0i.w = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R5i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R5i.y)); +PS0i = R127i.z; +// 1 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.w) * 0.0 + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R4i.z) * 1.0); +R125i.z = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R6i.x) + intBitsToFloat(PV0i.z))); +PV1i.z = R125i.z; +R126i.w = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R6i.y) + intBitsToFloat(PV0i.w))); +PV1i.w = R126i.w; +R125i.w = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R5i.x)); +PS1i = R125i.w; +// 2 +R124i.x = floatBitsToInt((intBitsToFloat(R1i.w) * 0.0 + intBitsToFloat(R0i.w))); +R126i.y = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R5i.y)); +R126i.z = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.z)); +R126i.x = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.x)); +PS0i = R126i.x; +// 3 +backupReg0i = R127i.y; +backupReg1i = R127i.z; +R0i.x = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R6i.x) + intBitsToFloat(R127i.x))); +R127i.y = floatBitsToInt((intBitsToFloat(R4i.w) * 0.0 + intBitsToFloat(backupReg0i))); +R127i.z = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R6i.y) + intBitsToFloat(backupReg1i))); +PV1i.w = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R125i.z)); +PS1i = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R126i.w)); +// 4 +backupReg0i = R126i.z; +R127i.x = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R125i.w) + intBitsToFloat(PV1i.w))); +PV0i.y = floatBitsToInt(intBitsToFloat(R11i.w) * intBitsToFloat(R125i.x)); +R126i.z = floatBitsToInt((intBitsToFloat(R4i.x) * intBitsToFloat(R125i.w) + intBitsToFloat(R127i.w))); +R123i.w = floatBitsToInt((intBitsToFloat(R4i.x) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg0i))); +PV0i.w = R123i.w; +R127i.w = floatBitsToInt((intBitsToFloat(R0i.z) * intBitsToFloat(R126i.y) + intBitsToFloat(PS1i))); +PS0i = R127i.w; +// 5 +backupReg0i = R126i.x; +backupReg1i = R0i.z; +R126i.x = floatBitsToInt(intBitsToFloat(R7i.w) * intBitsToFloat(R125i.z)); +R123i.y = floatBitsToInt((intBitsToFloat(R4i.x) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg0i))); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(R7i.w) * intBitsToFloat(R126i.w)); +R126i.w = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.y))); +R125i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R127i.z) + intBitsToFloat(PV0i.w))); +PS1i = R125i.y; +// 6 +backupReg0i = R126i.y; +R5i.x = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(R126i.z))); +R126i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R127i.y) + intBitsToFloat(PV1i.y))); +PV0i.y = R126i.y; +PV0i.z = floatBitsToInt(intBitsToFloat(R7i.w) * intBitsToFloat(R125i.x)); +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(PV1i.z))); +PV0i.w = R123i.w; +R6i.z = 0; +PS0i = R6i.z; +// 7 +backupReg0i = R125i.w; +backupReg1i = R126i.x; +R126i.x = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.z))); +R0i.y = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(R127i.z) + intBitsToFloat(PV0i.w))); +R126i.z = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(PV0i.y)); +R125i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(backupReg1i))); +PS1i = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(PV0i.y)); +// 8 +R6i.x = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(R127i.x))); +R124i.y = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R127i.z) + intBitsToFloat(R127i.w))); +R127i.z = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(R127i.y) + intBitsToFloat(R126i.w))); +R4i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PS1i))); +PS0i = R4i.x; +// 9 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R125i.y),intBitsToFloat(R126i.y),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.x = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.w))); +PS1i = R7i.x; +// 10 +backupReg0i = R127i.y; +backupReg1i = R126i.x; +backupReg2i = R126i.z; +R126i.x = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[6].y)); +R127i.y = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[6].z)); +R126i.z = floatBitsToInt((intBitsToFloat(R12i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(backupReg1i))); +R125i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[6].x)); +R0i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg2i))); +PS0i = R0i.x; +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R124i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.w = tempi.x; +R127i.x = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(R127i.z)); +PS1i = R127i.x; +// 12 +backupReg0i = R0i.y; +R125i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R13i.y),intBitsToFloat(R13i.z),-0.0),vec4(intBitsToFloat(R7i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R126i.z),0.0))); +PV0i.x = R125i.x; +PV0i.y = R125i.x; +PV0i.z = R125i.x; +PV0i.w = R125i.x; +R124i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R125i.w))); +PS0i = R124i.x; +// 13 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(R124i.y) + intBitsToFloat(backupReg0i))); +PV1i.y = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R126i.z)); +R123i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R127i.y))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R126i.x))); +PV1i.w = R123i.w; +PS1i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R127i.z)); +// 14 +R13i.x = floatBitsToInt((intBitsToFloat(R125i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R124i.x))); +R13i.y = floatBitsToInt((intBitsToFloat(R125i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV1i.w))); +R13i.z = floatBitsToInt((intBitsToFloat(R125i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV1i.z))); +R126i.w = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R0i.y) + intBitsToFloat(PV1i.y))); +R125i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R124i.y) + intBitsToFloat(PS1i))); +PS0i = R125i.x; +// 15 +PV1i.x = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(R126i.z)); +R123i.w = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(R4i.x))); +PV1i.w = R123i.w; +// 16 +R123i.x = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(R0i.x))); +PV0i.x = R123i.x; +R124i.y = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[6].y)); +R126i.z = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[6].z)); +R127i.w = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[6].x)); +R124i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(R0i.y) + intBitsToFloat(PV1i.x))); +PS0i = R124i.x; +// 17 +R123i.x = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(R6i.x) + intBitsToFloat(R127i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].x)); +R127i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].z)); +R125i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].y)); +// 18 +backupReg0i = R125i.x; +R125i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R126i.z))); +R123i.y = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R6i.x) + intBitsToFloat(backupReg0i))); +PV0i.y = R123i.y; +R126i.z = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R127i.w))); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R124i.y))); +// 19 +backupReg0i = R124i.x; +backupReg1i = R127i.z; +R124i.x = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R127i.y))); +R123i.y = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(R7i.x) + intBitsToFloat(backupReg0i))); +PV1i.y = R123i.y; +R127i.z = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R125i.w))); +R125i.w = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(backupReg1i))); +// 20 +R11i.x = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R126i.z))); +R11i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R127i.w))); +R123i.z = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R7i.x) + intBitsToFloat(R126i.w))); +PV0i.z = R123i.z; +R11i.z = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R125i.x))); +PS0i = R11i.z; +// 21 +R5i.x = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R124i.x))); +R5i.y = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R127i.z))); +R5i.z = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R125i.w))); +// 22 +R7i.z = R10i.z; +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].w) * 1.0); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].x) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].z) * 1.0); +PV0i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].y) * 1.0); +R1i.w = 0; +PS0i = R1i.w; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].x) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].y) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +R10i.z = R3i.w; +R10i.z = floatBitsToInt(intBitsToFloat(R10i.z) * 2.0); +PS1i = R10i.z; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +R4i.x = ((0.0 >= intBitsToFloat(PS1i))?int(0xFFFFFFFF):int(0x0)); +PS0i = R4i.x; +// 3 +R125i.x = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV0i.y))); +PV1i.x = R125i.x; +R124i.y = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.w))); +PV1i.y = R124i.y; +R126i.z = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R126i.z; +R0i.w = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].w) + intBitsToFloat(PV0i.x))); +PV1i.w = R0i.w; +R127i.w = floatBitsToInt((intBitsToFloat(R10i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS1i = R127i.w; +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.w)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R10i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 5 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].y) + -(intBitsToFloat(0x3dcccccd))); +PV1i.y = floatBitsToInt(intBitsToFloat(R7i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R7i.z)) + intBitsToFloat(uf_remappedVS[11].x)); +PV1i.w = floatBitsToInt(-(intBitsToFloat(R6i.z)) + -(intBitsToFloat(PV0i.x))); +PS1i = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].w) + -(intBitsToFloat(0x3dcccccd))); +// 6 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.w)) + intBitsToFloat(PV1i.z)); +R126i.y = ((intBitsToFloat(PS1i) >= 0.0)?(floatBitsToInt(1.0)):(0)); +R127i.z = ((intBitsToFloat(PV1i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.w) + -(intBitsToFloat(PV1i.y))); +R125i.y = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[12].w)) + 1.0); +PS0i = R125i.y; +// 7 +R0i.x = ((-(1.0) > intBitsToFloat(uf_remappedVS[0].y))?int(0xFFFFFFFF):int(0x0)); +R123i.y = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.y = R123i.y; +R123i.z = ((intBitsToFloat(PV0i.w) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.z = R123i.z; +PV1i.w = floatBitsToInt(fract(intBitsToFloat(R127i.w))); +PS1i = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +// 8 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R127i.z)); +R123i.y = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(R126i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].x) + -(1.0)); +PS0i = R127i.z; +// 9 +R126i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(0x3e22f983)); +PV1i.x = R126i.x; +R126i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3e22f983)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(PV0i.w)); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].y) + -(1.0)); +R127i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].z) + -(1.0)); +PS1i = R127i.x; +// 10 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + -(0.0)); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[14].x) + -(intBitsToFloat(uf_remappedVS[14].y))); +R0i.z = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R2i.w = floatBitsToInt((intBitsToFloat(R127i.z) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R127i.w = floatBitsToInt(sin((intBitsToFloat(PV1i.x))/0.1591549367)); +PS0i = R127i.w; +// 11 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +R0i.y = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R4i.z = ((intBitsToFloat(uf_remappedVS[14].x) == intBitsToFloat(uf_remappedVS[14].y))?int(0xFFFFFFFF):int(0x0)); +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +R10i.y = floatBitsToInt(sin((intBitsToFloat(R126i.y))/0.1591549367)); +PS1i = R10i.y; +// 12 +backupReg0i = R126i.y; +R10i.x = floatBitsToInt(intBitsToFloat(R13i.x) * intBitsToFloat(PV1i.w)); +PV0i.x = R10i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R13i.y) * intBitsToFloat(PV1i.w)); +PV0i.y = R126i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R13i.z) * intBitsToFloat(PV1i.w)); +PV0i.z = R127i.z; +R125i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R124i.x = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +PS0i = R124i.x; +// 13 +backupReg0i = R125i.y; +backupReg0i = R125i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(R125i.y)); +R125i.y = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(backupReg0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(backupReg0i)); +PS1i = floatBitsToInt(cos((intBitsToFloat(R126i.x))/0.1591549367)); +// 14 +R2i.xyz = floatBitsToInt(vec3(intBitsToFloat(R125i.x),intBitsToFloat(R124i.y),intBitsToFloat(R126i.z)) + vec3(intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.w))); +PV0i.x = R2i.x; +PV0i.y = R2i.y; +PV0i.z = R2i.z; +R126i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R122i.x = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(R1i.y) + intBitsToFloat(R127i.x))); +PS0i = R122i.x; +// 15 +backupReg0i = R0i.w; +R1i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)))); +PV1i.x = R1i.x; +PV1i.y = R1i.x; +PV1i.z = R1i.x; +PV1i.w = R1i.x; +R125i.x = floatBitsToInt((intBitsToFloat(R9i.w) * intBitsToFloat(PS0i) + intBitsToFloat(R9i.y))); +PS1i = R125i.x; +// 16 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R6i.y = tempi.x; +R127i.x = floatBitsToInt((-(intBitsToFloat(R127i.w)) * intBitsToFloat(R1i.y) + intBitsToFloat(R126i.w))); +PS0i = R127i.x; +// 17 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.z = tempi.x; +R4i.y = floatBitsToInt(1.0 / intBitsToFloat(R127i.y)); +PS1i = R4i.y; +// 18 +backupReg0i = R1i.y; +R123i.x = floatBitsToInt((-(intBitsToFloat(R10i.y)) * intBitsToFloat(R1i.y) + intBitsToFloat(R125i.y))); +PV0i.x = R123i.x; +R1i.y = floatBitsToInt((intBitsToFloat(R9i.z) * intBitsToFloat(R127i.x) + intBitsToFloat(R9i.x))); +R126i.z = floatBitsToInt((intBitsToFloat(R124i.x) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.w))); +R125i.w = floatBitsToInt(-(intBitsToFloat(PV1i.x)) * intBitsToFloat(0x42800000)); +R1i.z = ((intBitsToFloat(uf_remappedVS[14].z) == 0.0)?int(0xFFFFFFFF):int(0x0)); +PS0i = R1i.z; +// 19 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(R10i.x),intBitsToFloat(R126i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R125i.y = floatBitsToInt((intBitsToFloat(R8i.z) * intBitsToFloat(PV0i.x) + intBitsToFloat(R8i.x))); +PS1i = R125i.y; +// 20 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R10i.x),intBitsToFloat(R126i.y),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(0x3a4ccccd)); +PS0i = R127i.w; +// 21 +backupReg0i = R8i.y; +R8i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3ab60b61)); +R8i.y = floatBitsToInt(intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[12].w)); +PV1i.y = R8i.y; +R9i.z = floatBitsToInt(intBitsToFloat(R125i.x) + 0.5); +R9i.w = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(R126i.z) + intBitsToFloat(backupReg0i))); +R7i.x = floatBitsToInt(intBitsToFloat(R125i.y) + 0.5); +PS1i = R7i.x; +// 22 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(R0i.w)),vec4(intBitsToFloat(uf_remappedVS[15].x),intBitsToFloat(uf_remappedVS[15].y),intBitsToFloat(uf_remappedVS[15].z),intBitsToFloat(uf_remappedVS[15].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R8i.w = tempi.x; +R8i.z = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R127i.w)); +PS0i = R8i.z; +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[16].x),intBitsToFloat(uf_remappedVS[16].y),intBitsToFloat(uf_remappedVS[16].z),intBitsToFloat(uf_remappedVS[16].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R125i.y = tempi.x; +R125i.x = floatBitsToInt(intBitsToFloat(R8i.y) * intBitsToFloat(R8i.x)); +PS0i = R125i.x; +// 1 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[17].x),intBitsToFloat(uf_remappedVS[17].y),intBitsToFloat(uf_remappedVS[17].z),intBitsToFloat(uf_remappedVS[17].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R125i.w = floatBitsToInt(intBitsToFloat(R8i.w) + intBitsToFloat(R8i.z)); +PS1i = R125i.w; +// 2 +backupReg0i = R125i.x; +R125i.x = ((R0i.x == 0)?(PS1i):(PS1i)); +R127i.y = floatBitsToInt(intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i)); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[0].z)); +R126i.w = floatBitsToInt(intBitsToFloat(R1i.y) + 0.5); +R1i.y = floatBitsToInt(intBitsToFloat(R9i.w) + 0.5); +PS0i = R1i.y; +// 3 +backupReg0i = R0i.w; +R124i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R2i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[18].x),intBitsToFloat(uf_remappedVS[18].y),intBitsToFloat(uf_remappedVS[18].z),intBitsToFloat(uf_remappedVS[18].w)))); +PV1i.x = R124i.x; +PV1i.y = R124i.x; +PV1i.z = R124i.x; +PV1i.w = R124i.x; +R127i.x = ((R0i.x == 0)?(PV0i.z):(R1i.w)); +PS1i = R127i.x; +// 4 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +R0i.x = ((R4i.x == 0)?(R125i.x):(0x3f800000)); +R123i.y = ((backupReg0i == 0)?(R127i.y):(R127i.y)); +PV0i.y = R123i.y; +R127i.z = floatBitsToInt(-(intBitsToFloat(R9i.z)) + 1.0); +R123i.w = ((backupReg0i == 0)?(PV1i.x):(PV1i.x)); +PV0i.w = R123i.w; +R124i.y = floatBitsToInt(-(intBitsToFloat(R6i.z))); +PS0i = R124i.y; +// 5 +backupReg0i = R2i.y; +R2i.x = 0; +R8i.y = ((R4i.x == 0)?(PV0i.y):(0x3f800000)); +R8i.z = ((R4i.x == 0)?(R127i.x):(0x3f800000)); +R0i.w = ((R4i.x == 0)?(PV0i.w):(0x3f800000)); +R2i.y = floatBitsToInt(intBitsToFloat(backupReg0i) + -(intBitsToFloat(uf_remappedVS[14].w))); +PS1i = R2i.y; +// 6 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R2i.z = 0; +PS0i = R2i.z; +// 7 +R127i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R11i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),0.0))); +PV1i.x = R127i.x; +PV1i.y = R127i.x; +PV1i.z = R127i.x; +PV1i.w = R127i.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +R127i.w = floatBitsToInt(tempResultf); +PS1i = R127i.w; +// 8 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R11i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R125i.y = tempi.x; +R125i.x = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(PS1i)); +PS0i = R125i.x; +// 9 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R11i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.z = tempi.x; +R126i.y = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R127i.w)); +PS1i = R126i.y; +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R125i.y),intBitsToFloat(PV1i.x),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R125i.y),intBitsToFloat(PV1i.x),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R127i.w)); +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R125i.x),intBitsToFloat(R126i.y),intBitsToFloat(PS0i),-0.0),vec4(-(intBitsToFloat(uf_remappedVS[19].x)),-(intBitsToFloat(uf_remappedVS[19].y)),-(intBitsToFloat(uf_remappedVS[19].z)),0.0))); +tempi.x = floatBitsToInt(intBitsToFloat(tempi.x) / 2.0); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 12 +backupReg0i = R2i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(PS1i)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + 0.5); +R1i.w = 0; +R2i.x = ((R1i.z == 0)?(backupReg0i):(R125i.w)); +PS0i = R2i.x; +// 13 +backupReg0i = R2i.z; +backupReg1i = R2i.y; +PV1i.y = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +R2i.z = ((R1i.z == 0)?(backupReg0i):(R124i.y)); +R125i.w = floatBitsToInt(max(intBitsToFloat(PV0i.y), 0.0)); +PV1i.w = R125i.w; +R2i.y = ((R1i.z == 0)?(backupReg1i):(R127i.y)); +PS1i = R2i.y; +// 14 +backupReg0i = R0i.z; +R123i.x = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[20].x) + intBitsToFloat(R2i.w))); +PV0i.x = R123i.x; +R7i.y = floatBitsToInt(-(intBitsToFloat(R1i.y)) + 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + -(intBitsToFloat(uf_remappedVS[14].y))); +R123i.w = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(uf_remappedVS[20].y) + intBitsToFloat(backupReg0i))); +PV0i.w = R123i.w; +R2i.w = ((R1i.z == 0)?(R1i.w):(R124i.x)); +PS0i = R2i.w; +// 15 +backupReg0i = R0i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.w) + -(1.0)); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.x) + -(1.0)); +R123i.z = floatBitsToInt((intBitsToFloat(R125i.w) * intBitsToFloat(uf_remappedVS[20].z) + intBitsToFloat(backupReg0i))); +PV1i.z = R123i.z; +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(R4i.y)); +R7i.z = R126i.w; +PS1i = R7i.z; +// 16 +R123i.x = ((R4i.z == 0)?(PV1i.w):(0x3f800000)); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.z) + -(1.0)); +R7i.w = R127i.z; +PS0i = R7i.w; +// 17 +backupReg0i = R3i.x; +backupReg1i = R3i.y; +R3i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.z)); +R3i.y = floatBitsToInt(intBitsToFloat(backupReg1i) * intBitsToFloat(PV0i.y)); +R0i.z = PV0i.x; +R0i.z = clampFI32(R0i.z); +R123i.w = floatBitsToInt((intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.w = R123i.w; +// 18 +backupReg0i = R3i.z; +R3i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.w)); +// 19 +predResult = (intBitsToFloat(uf_remappedVS[11].y) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(-(intBitsToFloat(R6i.z)) + -(intBitsToFloat(uf_remappedVS[11].x))); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].x)) + intBitsToFloat(uf_remappedVS[11].y)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R10i.z; +R10i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +predResult = (intBitsToFloat(uf_remappedVS[11].w) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(intBitsToFloat(R6i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].z)) + intBitsToFloat(uf_remappedVS[11].w)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R10i.z; +R10i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = ((0.0 >= intBitsToFloat(uf_remappedVS[0].w))?int(0xFFFFFFFF):int(0x0)); +R127i.y = floatBitsToInt(-(intBitsToFloat(R6i.z)) + -(intBitsToFloat(uf_remappedVS[21].x))); +R3i.w = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(R10i.z)); +PS0i = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(R6i.z)); +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.w; +R0i.x = ((PV0i.x == 0)?(backupReg0i):(0x3f800000)); +R0i.y = ((PV0i.x == 0)?(R8i.y):(0x3f800000)); +R0i.z = ((PV0i.x == 0)?(R8i.z):(0x3f800000)); +R0i.w = ((PV0i.x == 0)?(backupReg1i):(0x3f800000)); +R122i.x = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(R6i.y) + intBitsToFloat(PS0i))); +PS1i = R122i.x; +// 2 +R123i.z = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(R1i.x) + intBitsToFloat(PS1i))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].y)); +// 3 +PV1i.z = floatBitsToInt(max(intBitsToFloat(PV0i.w), 0.0)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.z)); +PS1i = floatBitsToInt(tempResultf); +// 4 +R127i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +PV0i.x = R127i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(PS1i)); +PV0i.y = R126i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(PS1i)); +PV0i.z = R127i.z; +tempResultf = log2(intBitsToFloat(PV1i.z)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +R127i.y = floatBitsToInt(tempResultf); +PS0i = R127i.y; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[22].x),intBitsToFloat(uf_remappedVS[22].y),intBitsToFloat(uf_remappedVS[22].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +// 6 +PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.x), -(intBitsToFloat(PV1i.x)))); +PV0i.y = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].z)); +PS0i = floatBitsToInt(intBitsToFloat(uf_remappedVS[23].z) * intBitsToFloat(R127i.z)); +// 7 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[23].y) * intBitsToFloat(R126i.y) + intBitsToFloat(PS0i))); +PV1i.x = R123i.x; +PV1i.w = floatBitsToInt(-(intBitsToFloat(PV0i.x)) + 1.0); +PS1i = floatBitsToInt(exp2(intBitsToFloat(PV0i.y))); +// 8 +R123i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[23].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R123i.x = clampFI32(R123i.x); +PV0i.x = R123i.x; +PV0i.z = floatBitsToInt(min(intBitsToFloat(PS1i), 1.0)); +tempResultf = log2(intBitsToFloat(PV1i.w)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0i = floatBitsToInt(tempResultf); +// 9 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[21].w)); +PV1i.y = floatBitsToInt(intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].w)); +tempResultf = log2(intBitsToFloat(PV0i.x)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1i = floatBitsToInt(tempResultf); +// 10 +PV0i.z = floatBitsToInt(intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[25].w)); +R1i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[19].w)); +R127i.x = floatBitsToInt(exp2(intBitsToFloat(PV1i.y))); +PS0i = R127i.x; +// 11 +R127i.z = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].y) + intBitsToFloat(uf_remappedVS[26].y))); +R127i.w = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].x) + intBitsToFloat(uf_remappedVS[26].x))); +R126i.y = floatBitsToInt(exp2(intBitsToFloat(PV0i.z))); +PS1i = R126i.y; +// 12 +R123i.y = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[24].z) + intBitsToFloat(uf_remappedVS[26].z))); +PV0i.y = R123i.y; +// 13 +R1i.x = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].x) + intBitsToFloat(R127i.w))); +R1i.y = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].y) + intBitsToFloat(R127i.z))); +R1i.z = floatBitsToInt((intBitsToFloat(R126i.y) * intBitsToFloat(uf_remappedVS[25].z) + intBitsToFloat(PV0i.y))); +} +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +// export +gl_Position = vec4(intBitsToFloat(R0i.x)*(origRatio / newRatio), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R3i.x), intBitsToFloat(R3i.y), intBitsToFloat(R3i.z), intBitsToFloat(R3i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +passParameterSem2 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +// export +passParameterSem3 = vec4(intBitsToFloat(R7i.x), intBitsToFloat(R7i.y), intBitsToFloat(R7i.z), intBitsToFloat(R7i.w)); +if( activeMaskStackC[1] == true ) { +// 0 +} +} diff --git a/Enhancement/XenobladeX_219_GUI/eec2c2cee7a1d42f_0000000000000000_vs.txt b/Enhancement/XenobladeX_219_GUI/eec2c2cee7a1d42f_0000000000000000_vs.txt new file mode 100644 index 00000000..3761626e --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/eec2c2cee7a1d42f_0000000000000000_vs.txt @@ -0,0 +1,1395 @@ +#version 420 +#extension GL_ARB_texture_gather : enable +#extension GL_ARB_shading_language_packing : enable +// shader eec2c2cee7a1d42f +//waterfall splashes cutscene, rain *dumped* +uniform ivec4 uf_remappedVS[27]; +uniform vec2 uf_windowSpaceToClipSpaceTransform; +layout(location = 0) in uvec4 attrDataSem0; +layout(location = 1) in uvec4 attrDataSem1; +layout(location = 2) in uvec4 attrDataSem2; +layout(location = 3) in uvec4 attrDataSem3; +layout(location = 4) in uvec4 attrDataSem4; +layout(location = 5) in uvec4 attrDataSem5; +layout(location = 6) in uvec4 attrDataSem6; +layout(location = 7) in uvec4 attrDataSem7; +layout(location = 8) in uvec4 attrDataSem8; +layout(location = 9) in uvec4 attrDataSem9; +layout(location = 10) in uvec4 attrDataSem10; +out gl_PerVertex +{ + vec4 gl_Position; + float gl_PointSize; +}; +layout(location = 0) out vec4 passParameterSem0; +layout(location = 2) out vec4 passParameterSem2; +layout(location = 3) out vec4 passParameterSem4; +layout(location = 1) out vec4 passParameterSem1; +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 R11i = ivec4(0); +ivec4 R12i = ivec4(0); +ivec4 R13i = ivec4(0); +ivec4 R14i = ivec4(0); +ivec4 R122i = ivec4(0); +ivec4 R123i = ivec4(0); +ivec4 R124i = ivec4(0); +ivec4 R125i = ivec4(0); +ivec4 R126i = 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; +bool activeMaskStack[5]; +bool activeMaskStackC[6]; +activeMaskStack[0] = false; +activeMaskStack[1] = false; +activeMaskStack[2] = false; +activeMaskStack[3] = false; +activeMaskStackC[0] = false; +activeMaskStackC[1] = false; +activeMaskStackC[2] = false; +activeMaskStackC[3] = false; +activeMaskStackC[4] = false; +activeMaskStack[0] = true; +activeMaskStackC[0] = true; +activeMaskStackC[1] = true; +vec3 cubeMapSTM; +int cubeMapFaceId; +R0i = ivec4(gl_VertexID, 0, 0, gl_InstanceID); +attrDecoder.xy = attrDataSem0.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R1i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder = attrDataSem1; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R2i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem5; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R6i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem6; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R7i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xyz = attrDataSem7.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R8i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder.xyz = attrDataSem4.xyz; +attrDecoder.xyz = (attrDecoder.xyz>>24)|((attrDecoder.xyz>>8)&0xFF00)|((attrDecoder.xyz<<8)&0xFF0000)|((attrDecoder.xyz<<24)); +attrDecoder.w = 0; +R5i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), floatBitsToInt(1.0)); +attrDecoder = attrDataSem8; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R9i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder = attrDataSem9; +attrDecoder = (attrDecoder>>24)|((attrDecoder>>8)&0xFF00)|((attrDecoder<<8)&0xFF0000)|((attrDecoder<<24)); +R10i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xy = attrDataSem10.xy; +attrDecoder.xy = (attrDecoder.xy>>24)|((attrDecoder.xy>>8)&0xFF00)|((attrDecoder.xy<<8)&0xFF0000)|((attrDecoder.xy<<24)); +attrDecoder.z = 0; +attrDecoder.w = 0; +R11i = ivec4(int(attrDecoder.x), int(attrDecoder.y), floatBitsToInt(0.0), floatBitsToInt(1.0)); +attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem2.xyzw)/255.0); +R3i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +attrDecoder.xyzw = floatBitsToUint(vec4(attrDataSem3.xyzw)/255.0); +R4i = ivec4(int(attrDecoder.x), int(attrDecoder.y), int(attrDecoder.z), int(attrDecoder.w)); +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R125i.x = floatBitsToInt(max(intBitsToFloat(R5i.x), -(intBitsToFloat(R5i.x)))); +PV0i.x = R125i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R7i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PV0i.y = R123i.y; +R127i.z = floatBitsToInt(max(intBitsToFloat(R5i.y), -(intBitsToFloat(R5i.y)))); +PV0i.z = R127i.z; +R127i.w = R5i.z; +R127i.y = floatBitsToInt((intBitsToFloat(R7i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 1 +R127i.x = floatBitsToInt(intBitsToFloat(R8i.x) * intBitsToFloat(PV0i.x)); +R123i.y = floatBitsToInt((intBitsToFloat(R7i.z) * intBitsToFloat(0x3e22f983) + 0.5)); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[0].x) + -(0.5)); +PV1i.w = floatBitsToInt(fract(intBitsToFloat(PV0i.y))); +R126i.x = floatBitsToInt(intBitsToFloat(R8i.y) * intBitsToFloat(PV0i.z)); +PS1i = R126i.x; +// 2 +PV0i.x = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +R127i.y = floatBitsToInt(fract(intBitsToFloat(PV1i.y))); +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.w) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.z = R123i.z; +PV0i.w = floatBitsToInt(intBitsToFloat(R8i.z) * intBitsToFloat(R127i.w)); +R124i.w = ((intBitsToFloat(PV1i.z) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PS0i = R124i.w; +// 3 +PV1i.x = floatBitsToInt(-(intBitsToFloat(R127i.w)) + intBitsToFloat(PV0i.w)); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R127i.z)) + intBitsToFloat(R126i.x)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R125i.x)) + intBitsToFloat(R127i.x)); +R5i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3e22f983)); +R126i.z = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PS1i = R126i.z; +// 4 +backupReg0i = R127i.y; +backupReg1i = R125i.x; +R125i.x = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.z))); +R127i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +R127i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(backupReg1i))); +R126i.y = R6i.x; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) * 2.0); +PS0i = R126i.y; +// 5 +R127i.x = R6i.z; +R127i.x = floatBitsToInt(intBitsToFloat(R127i.x) * 2.0); +R125i.y = floatBitsToInt(intBitsToFloat(R5i.x) * intBitsToFloat(R8i.x)); +R125i.z = floatBitsToInt(intBitsToFloat(R5i.y) * intBitsToFloat(R8i.y)); +R126i.w = R6i.y; +R126i.w = floatBitsToInt(intBitsToFloat(R126i.w) * 2.0); +R125i.w = floatBitsToInt(intBitsToFloat(R5i.z) * intBitsToFloat(R8i.z)); +PS1i = R125i.w; +// 6 +PV0i.x = R8i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) / 2.0); +R0i.y = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(0x3e22f983)); +PV0i.z = 0; +PV0i.w = R8i.y; +PV0i.w = floatBitsToInt(intBitsToFloat(PV0i.w) / 2.0); +R126i.z = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(0x3e22f983)); +PS0i = R126i.z; +// 7 +backupReg0i = R126i.w; +R0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(R127i.w)); +R7i.y = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(R127i.y)); +R11i.z = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R125i.x)); +R126i.w = floatBitsToInt(intBitsToFloat(R6i.x) * intBitsToFloat(R126i.y)); +R124i.y = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(backupReg0i)); +PS1i = R124i.y; +// 8 +PV0i.x = R6i.y; +PV0i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * 2.0); +R127i.y = R6i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R127i.y) * 2.0); +PV0i.z = R6i.z; +PV0i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * 2.0); +R127i.w = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(R127i.x)); +R126i.y = R6i.w; +R126i.y = floatBitsToInt(intBitsToFloat(R126i.y) * 2.0); +PS0i = R126i.y; +// 9 +backupReg0i = R125i.y; +R127i.x = floatBitsToInt(-(intBitsToFloat(R5i.z)) + intBitsToFloat(R125i.w)); +R125i.y = floatBitsToInt(-(intBitsToFloat(R5i.y)) + intBitsToFloat(R125i.z)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R5i.x)) + intBitsToFloat(backupReg0i)); +R0i.w = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(PV0i.x)); +R125i.x = floatBitsToInt(intBitsToFloat(R6i.x) * intBitsToFloat(PV0i.z)); +PS1i = R125i.x; +// 10 +R124i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R0i.x),intBitsToFloat(R7i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R7i.y),intBitsToFloat(R11i.z),0.0))); +PV0i.x = R124i.x; +PV0i.y = R124i.x; +PV0i.z = R124i.x; +PV0i.w = R124i.x; +R125i.w = floatBitsToInt((intBitsToFloat(PV1i.z) * intBitsToFloat(R124i.w) + intBitsToFloat(R5i.x))); +PS0i = R125i.w; +// 11 +backupReg0i = R127i.x; +backupReg1i = R125i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R6i.x) * intBitsToFloat(R126i.y)); +R125i.y = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R124i.w) + intBitsToFloat(R5i.z))); +R125i.z = floatBitsToInt((intBitsToFloat(backupReg1i) * intBitsToFloat(R124i.w) + intBitsToFloat(R5i.y))); +R124i.w = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(R126i.y)); +PS1i = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w)); +// 12 +R126i.x = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(R126i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(R127i.y)); +R6i.w = floatBitsToInt(-(intBitsToFloat(PS1i)) + 1.0); +R0i.z = 0; +PS0i = R0i.z; +// 13 +R0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(R8i.x)); +PV1i.x = R0i.x; +R5i.y = floatBitsToInt(intBitsToFloat(R1i.y) * intBitsToFloat(R8i.y)); +PV1i.y = R5i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(R124i.y) + intBitsToFloat(R127i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R126i.w) + intBitsToFloat(R124i.y)); +R13i.x = 0; +PS1i = R13i.x; +// 14 +R0i.x = floatBitsToInt(intBitsToFloat(PV1i.x) + intBitsToFloat(R125i.w)); +R7i.y = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R125i.z)); +R14i.z = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(R125i.y)); +R8i.w = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + 1.0); +R8i.y = 0; +PS0i = R8i.y; +// 15 +R5i.x = floatBitsToInt(intBitsToFloat(R0i.w) + intBitsToFloat(R127i.x)); +R5i.y = 0x3f800000; +R8i.z = 0; +R11i.w = floatBitsToInt(intBitsToFloat(R127i.z) + -(intBitsToFloat(R124i.w))); +R12i.w = floatBitsToInt(intBitsToFloat(R125i.x) + intBitsToFloat(R126i.x)); +PS1i = R12i.w; +// 16 +R8i.x = 0x3f800000; +R0i.z = floatBitsToInt(intBitsToFloat(R0i.w) + -(intBitsToFloat(R127i.x))); +R4i.w = floatBitsToInt(intBitsToFloat(R127i.z) + intBitsToFloat(R124i.w)); +R13i.w = floatBitsToInt(intBitsToFloat(R125i.x) + -(intBitsToFloat(R126i.x))); +PS0i = R13i.w; +// 17 +R1i.z = floatBitsToInt(-(intBitsToFloat(R127i.w)) + 1.0); +R7i.z = 0; +PS1i = R7i.z; +// 18 +R12i.z = 0; +PS0i = floatBitsToInt(sin((intBitsToFloat(R5i.w))/0.1591549367)); +// 19 +R127i.z = PS0i; +R0i.w = floatBitsToInt(-(intBitsToFloat(PS0i)) * 1.0); +PS1i = floatBitsToInt(cos((intBitsToFloat(R5i.w))/0.1591549367)); +// 20 +R127i.w = PS1i; +R1i.w = floatBitsToInt(intBitsToFloat(PS1i) * 1.0); +PS0i = R1i.w; +// 21 +PS1i = floatBitsToInt(sin((intBitsToFloat(R0i.y))/0.1591549367)); +// 22 +backupReg0i = R0i.y; +R0i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +R5i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS1i)); +R2i.w = floatBitsToInt(-(intBitsToFloat(PS1i)) * 1.0); +PS0i = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +// 23 +R14i.y = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS0i)); +R6i.z = floatBitsToInt(intBitsToFloat(R127i.w) * intBitsToFloat(PS0i)); +R5i.w = floatBitsToInt(intBitsToFloat(PS0i) * 1.0); +R127i.w = floatBitsToInt(sin((intBitsToFloat(R126i.z))/0.1591549367)); +PS1i = R127i.w; +// 24 +R6i.x = PS1i; +PS0i = floatBitsToInt(cos((intBitsToFloat(R126i.z))/0.1591549367)); +// 25 +R14i.x = PS0i; +R13i.y = floatBitsToInt(-(intBitsToFloat(R127i.w))); +R6i.y = PS0i; +PS1i = R6i.y; +// 26 +R13i.z = floatBitsToInt(sqrt(intBitsToFloat(R124i.x))); +PS0i = R13i.z; +// 27 +predResult = (intBitsToFloat(0xc0200000) > intBitsToFloat(R7i.w)); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.xyz = ivec3(R5i.z,R0i.w,R6i.z); +PV0i.x = R127i.x; +PV0i.y = R127i.y; +PV0i.z = R127i.z; +R127i.w = 0; +R8i.x = uf_remappedVS[1].z; +PS0i = R8i.x; +// 1 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +// 2 +backupReg0i = R127i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +// 3 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),-0.0),vec4(intBitsToFloat(R126i.x),intBitsToFloat(PV0i.x),intBitsToFloat(R127i.w),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R8i.y = uf_remappedVS[4].z; +PS1i = R8i.y; +// 4 +R8i.z = uf_remappedVS[5].z; +tempResultf = 1.0 / sqrt(intBitsToFloat(PV1i.x)); +PS0i = floatBitsToInt(tempResultf); +// 5 +backupReg0i = R126i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(PS0i)); +PV1i.x = R126i.x; +R127i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PS0i)); +PV1i.y = R127i.y; +// 6 +backupReg0i = R0i.x; +backupReg0i = R0i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(R1i.x) * -(intBitsToFloat(PV1i.x))); +PV0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.y)); +PV0i.z = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PV1i.y)); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * -(intBitsToFloat(PV1i.x))); +// 7 +backupReg0i = R127i.y; +R123i.x = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R1i.y) + intBitsToFloat(PV0i.z))); +R123i.z = floatBitsToInt((intBitsToFloat(backupReg0i) * intBitsToFloat(R7i.y) + intBitsToFloat(PV0i.w))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(R7i.y) + intBitsToFloat(PV0i.y))); +PV1i.w = R123i.w; +// 8 +R0i.x = PV1i.z; +PV0i.x = R0i.x; +R0i.y = PV1i.w; +PV0i.y = R0i.y; +R5i.x = PV1i.x; +PS0i = R5i.x; +// 9 +R14i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV1i.x = R14i.x; +PV1i.y = R14i.x; +PV1i.z = R14i.x; +PV1i.w = R14i.x; +R5i.y = R127i.y; +PS1i = R5i.y; +// 10 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R14i.y = tempi.x; +// 11 +backupReg0i = R0i.x; +backupReg1i = R0i.y; +backupReg2i = R14i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(backupReg2i),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R14i.z = tempi.x; +// 12 +R6i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[1].x),intBitsToFloat(uf_remappedVS[1].y),intBitsToFloat(uf_remappedVS[1].z),0.0))); +PV0i.x = R6i.x; +PV0i.y = R6i.x; +PV0i.z = R6i.x; +PV0i.w = R6i.x; +// 13 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[4].x),intBitsToFloat(uf_remappedVS[4].y),intBitsToFloat(uf_remappedVS[4].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.y = tempi.x; +// 14 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R12i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[5].x),intBitsToFloat(uf_remappedVS[5].y),intBitsToFloat(uf_remappedVS[5].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R6i.z = tempi.x; +} +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 +predResult = (0.5 > intBitsToFloat(R7i.w)); +activeMaskStack[2] = predResult; +activeMaskStackC[3] = predResult == true && activeMaskStackC[2] == true; +} +else { +activeMaskStack[2] = false; +activeMaskStackC[3] = false; +} +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +R13i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R14i.x),intBitsToFloat(R13i.y),intBitsToFloat(R8i.z),-0.0),vec4(intBitsToFloat(R0i.x),intBitsToFloat(R7i.y),intBitsToFloat(R14i.z),0.0))); +PV0i.x = R13i.x; +PV0i.y = R13i.x; +PV0i.z = R13i.x; +PV0i.w = R13i.x; +R5i.x = uf_remappedVS[1].x; +PS0i = R5i.x; +// 1 +backupReg0i = R0i.x; +backupReg1i = R7i.y; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R8i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(R14i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R7i.y = tempi.x; +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R8i.z)); +R5i.y = uf_remappedVS[1].y; +R5i.z = uf_remappedVS[1].z; +// 3 +R0i.xyz = ivec3(uf_remappedVS[4].x,uf_remappedVS[4].y,uf_remappedVS[4].z); +R122i.x = floatBitsToInt((intBitsToFloat(R1i.y) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.x))); +PS1i = R122i.x; +// 4 +backupReg0i = R12i.z; +R12i.xyz = ivec3(uf_remappedVS[5].x,uf_remappedVS[5].y,uf_remappedVS[5].z); +PV0i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R8i.z)); +R7i.x = floatBitsToInt((intBitsToFloat(R1i.x) * intBitsToFloat(R14i.x) + intBitsToFloat(PS1i))); +PS0i = R7i.x; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(PV0i.w),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R13i.y = tempi.x; +R1i.z = 0; +PS1i = R1i.z; +// 6 +predResult = (intBitsToFloat(0xbfc00000) > intBitsToFloat(R7i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = uf_remappedVS[1].w; +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].z) * 1.0); +R127i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].z) * 1.0); +R126i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[4].w))); +// 1 +PV1i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[1].y)); +R5i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * 0.0 + intBitsToFloat(PV0i.y))); +PS1i = R5i.z; +// 2 +R5i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.z))); +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[1].y)); +// 3 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[4].y)); +R0i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * 0.0 + intBitsToFloat(R127i.z))); +// 4 +R0i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R127i.x) + intBitsToFloat(PV1i.x))); +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[4].y)); +// 5 +R126i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[4].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 6 +R126i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[1].w) * intBitsToFloat(uf_remappedVS[5].y)); +// 7 +R5i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[1].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.y))); +PV1i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[5].z) * 1.0); +// 8 +R12i.x = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R127i.x) + intBitsToFloat(R126i.y))); +R0i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[4].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R127i.w))); +R12i.z = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * 0.0 + intBitsToFloat(PV1i.w))); +R12i.y = floatBitsToInt((intBitsToFloat(uf_remappedVS[5].x) * intBitsToFloat(R126i.w) + intBitsToFloat(R126i.x))); +PS0i = R12i.y; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +activeMaskStack[4] = activeMaskStack[3]; +activeMaskStackC[5] = activeMaskStackC[4]; +// 0 +predResult = (0.0 > intBitsToFloat(R7i.w)); +activeMaskStack[4] = predResult; +activeMaskStackC[5] = predResult == true && activeMaskStackC[4] == true; +} +else { +activeMaskStack[4] = false; +activeMaskStackC[5] = false; +} +if( activeMaskStackC[5] == true ) { +// 0 +R5i.y = 0; +R5i.z = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[5].x))); +R0i.y = 0x3f800000; +PS0i = R0i.y; +// 1 +R12i.y = 0; +R0i.z = 0; +R12i.z = uf_remappedVS[1].x; +PS1i = R12i.z; +// 2 +R11i.z = 0; +// 3 +R7i.z = R13i.z; +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +R14i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R7i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),0.0))); +PV0i.x = R14i.x; +PV0i.y = R14i.x; +PV0i.z = R14i.x; +PV0i.w = R14i.x; +R8i.x = R5i.z; +PS0i = R8i.x; +// 1 +backupReg0i = R0i.x; +backupReg1i = R0i.z; +backupReg1i = R0i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R7i.y),intBitsToFloat(R14i.z),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),intBitsToFloat(backupReg1i),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R14i.y = tempi.x; +R8i.y = backupReg1i; +PS1i = R8i.y; +// 2 +backupReg0i = R14i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R13i.x),intBitsToFloat(R7i.y),intBitsToFloat(backupReg0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(R12i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R14i.z = tempi.x; +R8i.z = R12i.z; +PS0i = R8i.z; +// 3 +backupReg0i = R0i.z; +R6i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R13i.y),intBitsToFloat(R1i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R5i.y),intBitsToFloat(R5i.z),0.0))); +PV1i.x = R6i.x; +PV1i.y = R6i.x; +PV1i.z = R6i.x; +PV1i.w = R6i.x; +PS1i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(backupReg0i)); +// 4 +backupReg0i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R13i.y),intBitsToFloat(PS1i),-0.0),vec4(intBitsToFloat(backupReg0i),intBitsToFloat(R0i.y),1.0,0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R6i.y = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R12i.z)); +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R13i.y),intBitsToFloat(PS0i),-0.0),vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),1.0,0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R6i.z = tempi.x; +} +activeMaskStack[2] = activeMaskStack[2] == false; +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +activeMaskStack[3] = activeMaskStack[2]; +activeMaskStackC[4] = activeMaskStackC[3]; +// 0 +predResult = (1.5 > intBitsToFloat(R7i.w)); +activeMaskStack[3] = predResult; +activeMaskStackC[4] = predResult == true && activeMaskStackC[3] == true; +} +else { +activeMaskStack[3] = false; +activeMaskStackC[4] = false; +} +if( activeMaskStackC[4] == true ) { +// 0 +R7i.x = R14i.z; +R7i.z = R0i.x; +R12i.x = R12i.z; +PS0i = R12i.x; +// 1 +R12i.y = R1i.y; +R12i.z = R1i.x; +} +activeMaskStack[3] = activeMaskStack[3] == false; +activeMaskStackC[4] = activeMaskStack[3] == true && activeMaskStackC[3] == true; +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = ((intBitsToFloat(0x40600000) > intBitsToFloat(R7i.w))?int(0xFFFFFFFF):int(0x0)); +PV0i.x = R127i.x; +R127i.y = ((intBitsToFloat(0x40200000) > intBitsToFloat(R7i.w))?int(0xFFFFFFFF):int(0x0)); +// 1 +R123i.x = ((PV0i.x == 0)?(R7i.y):(R0i.x)); +PV1i.x = R123i.x; +R123i.y = ((PV0i.x == 0)?(R14i.z):(R14i.z)); +PV1i.y = R123i.y; +R123i.z = ((PV0i.x == 0)?(R1i.y):(R1i.x)); +PV1i.z = R123i.z; +R123i.w = ((PV0i.x == 0)?(R0i.x):(R7i.y)); +PV1i.w = R123i.w; +R127i.z = ((PV0i.x == 0)?(R1i.x):(R1i.y)); +PS1i = R127i.z; +// 2 +backupReg0i = R7i.y; +R7i.x = ((R127i.y == 0)?(PV1i.x):(R0i.x)); +R7i.y = ((R127i.y == 0)?(PV1i.w):(R14i.z)); +R7i.z = ((R127i.y == 0)?(PV1i.y):(backupReg0i)); +R123i.w = ((R127i.x == 0)?(R12i.z):(R12i.z)); +PV0i.w = R123i.w; +R12i.x = ((R127i.y == 0)?(PV1i.z):(R1i.x)); +PS0i = R12i.x; +// 3 +R8i.x = ((R127i.y == 0)?(0):(R13i.x)); +R12i.y = ((R127i.y == 0)?(R127i.z):(R12i.z)); +R12i.z = ((R127i.y == 0)?(PV0i.w):(R1i.y)); +R8i.y = ((R127i.y == 0)?(0):(R5i.y)); +PS1i = R8i.y; +// 4 +backupReg0i = R8i.z; +R8i.z = ((R127i.y == 0)?(0x3f800000):(backupReg0i)); +} +activeMaskStackC[3] = activeMaskStack[2] == true && activeMaskStackC[2] == true; +if( activeMaskStackC[3] == true ) { +// 0 +backupReg0i = R0i.y; +R127i.x = floatBitsToInt(intBitsToFloat(R0i.y) * intBitsToFloat(R6i.x)); +PV0i.y = floatBitsToInt(intBitsToFloat(R6i.z) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(R14i.y) * intBitsToFloat(R6i.x)); +PV0i.w = floatBitsToInt(intBitsToFloat(R14i.y) * intBitsToFloat(R6i.y)); +R127i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(R6i.y)); +PS0i = R127i.z; +// 1 +R126i.x = floatBitsToInt((intBitsToFloat(R2i.w) * 0.0 + intBitsToFloat(PV0i.y))); +PV1i.x = R126i.x; +R127i.y = floatBitsToInt(intBitsToFloat(R5i.z) * 1.0); +R125i.z = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R14i.x) + intBitsToFloat(PV0i.z))); +PV1i.z = R125i.z; +R126i.w = floatBitsToInt((intBitsToFloat(R2i.w) * intBitsToFloat(R13i.y) + intBitsToFloat(PV0i.w))); +PV1i.w = R126i.w; +R124i.w = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R6i.x)); +PS1i = R124i.w; +// 2 +R124i.x = floatBitsToInt((intBitsToFloat(R1i.w) * 0.0 + intBitsToFloat(R0i.w))); +R126i.y = floatBitsToInt(intBitsToFloat(R1i.w) * intBitsToFloat(R6i.y)); +R126i.z = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.w)); +R127i.w = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.z)); +R125i.x = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(PV1i.x)); +PS0i = R125i.x; +// 3 +R0i.x = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(R14i.x) + intBitsToFloat(R127i.x))); +R125i.y = floatBitsToInt((intBitsToFloat(R5i.w) * 0.0 + intBitsToFloat(R127i.y))); +R124i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(R13i.y) + intBitsToFloat(R127i.z))); +R125i.w = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(R125i.z)); +R127i.z = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(R126i.w)); +PS1i = R127i.z; +// 4 +backupReg0i = R126i.x; +backupReg1i = R126i.z; +backupReg0i = R126i.x; +R126i.x = floatBitsToInt(intBitsToFloat(R12i.w) * intBitsToFloat(R125i.z)); +PV0i.y = floatBitsToInt(intBitsToFloat(R0i.z) * intBitsToFloat(backupReg0i)); +R126i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(R124i.w) + intBitsToFloat(R127i.w))); +R127i.w = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg1i))); +R125i.z = floatBitsToInt(intBitsToFloat(R12i.w) * intBitsToFloat(backupReg0i)); +PS0i = R125i.z; +// 5 +backupReg0i = R125i.x; +backupReg1i = R127i.z; +R125i.x = floatBitsToInt(intBitsToFloat(R12i.w) * intBitsToFloat(R126i.w)); +R127i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg0i))); +R127i.z = floatBitsToInt((intBitsToFloat(R6i.w) * intBitsToFloat(R124i.x) + intBitsToFloat(PV0i.y))); +R126i.w = floatBitsToInt((intBitsToFloat(R6i.w) * intBitsToFloat(R126i.y) + intBitsToFloat(backupReg1i))); +R11i.z = 0; +PS1i = R11i.z; +// 6 +R127i.x = floatBitsToInt((intBitsToFloat(R6i.w) * intBitsToFloat(R124i.w) + intBitsToFloat(R125i.w))); +// 7 +backupReg0i = R126i.y; +backupReg1i = R124i.x; +R124i.x = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(R126i.z))); +R126i.y = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R127i.w))); +R126i.z = floatBitsToInt((intBitsToFloat(R13i.w) * intBitsToFloat(R125i.y) + intBitsToFloat(R127i.y))); +PV1i.z = R126i.z; +R127i.w = floatBitsToInt((intBitsToFloat(R11i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.x))); +R125i.x = floatBitsToInt((intBitsToFloat(R11i.w) * intBitsToFloat(backupReg1i) + intBitsToFloat(R125i.z))); +PS1i = R125i.x; +// 8 +backupReg0i = R127i.z; +R5i.x = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(R127i.x))); +R127i.y = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(PV1i.z)); +R127i.z = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R125i.y) + intBitsToFloat(backupReg0i))); +R123i.w = floatBitsToInt((intBitsToFloat(R11i.w) * intBitsToFloat(R124i.w) + intBitsToFloat(R126i.x))); +PV0i.w = R123i.w; +PS0i = floatBitsToInt(intBitsToFloat(R8i.z) * intBitsToFloat(PV1i.z)); +// 9 +backupReg0i = R125i.y; +R6i.x = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(R0i.x) + intBitsToFloat(PV0i.w))); +R125i.y = floatBitsToInt((intBitsToFloat(R4i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R126i.w))); +R125i.z = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(backupReg0i) + intBitsToFloat(R125i.x))); +R125i.x = floatBitsToInt((intBitsToFloat(R8i.y) * intBitsToFloat(R126i.y) + intBitsToFloat(PS0i))); +PS1i = R125i.x; +// 10 +backupReg0i = R126i.z; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(R124i.x),intBitsToFloat(R126i.y),intBitsToFloat(backupReg0i),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.z = tempi.x; +R124i.y = floatBitsToInt((intBitsToFloat(R8i.w) * intBitsToFloat(R124i.z) + intBitsToFloat(R127i.w))); +PS0i = R124i.y; +// 11 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(R5i.x),intBitsToFloat(R125i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.w = tempi.x; +R127i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[6].x)); +PS1i = R127i.w; +// 12 +backupReg0i = R126i.z; +backupReg1i = R125i.x; +R125i.x = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R126i.y) + intBitsToFloat(R127i.y))); +R127i.y = floatBitsToInt(intBitsToFloat(R126i.z) * intBitsToFloat(uf_remappedVS[6].z)); +R126i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].y)); +R124i.w = floatBitsToInt((intBitsToFloat(R8i.x) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg1i))); +R0i.x = floatBitsToInt(intBitsToFloat(R8i.z) * intBitsToFloat(R127i.z)); +PS0i = R0i.x; +// 13 +R126i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R7i.x),intBitsToFloat(R7i.y),intBitsToFloat(R7i.z),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R124i.y),intBitsToFloat(R125i.z),0.0))); +PV1i.x = R126i.x; +PV1i.y = R126i.x; +PV1i.z = R126i.x; +PV1i.w = R126i.x; +R127i.x = floatBitsToInt((intBitsToFloat(R126i.w) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R127i.w))); +PS1i = R127i.x; +// 14 +backupReg0i = R125i.x; +backupReg1i = R127i.y; +R125i.x = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R124i.x) + intBitsToFloat(backupReg0i))); +R127i.y = floatBitsToInt(intBitsToFloat(R8i.y) * intBitsToFloat(R124i.y)); +R123i.z = floatBitsToInt((intBitsToFloat(R126i.w) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(backupReg1i))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R126i.w) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R126i.z))); +PV0i.w = R123i.w; +PS0i = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R127i.z)); +// 15 +R14i.x = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(R127i.x))); +R14i.y = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.w))); +R14i.z = floatBitsToInt((intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.z))); +R123i.w = floatBitsToInt((intBitsToFloat(R12i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(PS0i))); +PV1i.w = R123i.w; +R122i.x = floatBitsToInt((intBitsToFloat(R8i.y) * intBitsToFloat(R125i.y) + intBitsToFloat(R0i.x))); +PS1i = R122i.x; +// 16 +backupReg0i = R124i.w; +backupReg0i = R124i.w; +R127i.x = floatBitsToInt((intBitsToFloat(R8i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(PS1i))); +R125i.y = floatBitsToInt((intBitsToFloat(R12i.x) * intBitsToFloat(R5i.x) + intBitsToFloat(PV1i.w))); +R127i.z = floatBitsToInt(intBitsToFloat(R124i.w) * intBitsToFloat(uf_remappedVS[6].y)); +R124i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].x)); +R126i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].z)); +PS0i = R126i.x; +// 17 +backupReg0i = R125i.x; +backupReg0i = R125i.x; +backupReg0i = R125i.x; +backupReg1i = R125i.z; +R125i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].x)); +PV1i.y = floatBitsToInt(intBitsToFloat(R12i.z) * intBitsToFloat(R125i.z)); +R125i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].z)); +R126i.w = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(uf_remappedVS[6].y)); +R122i.x = floatBitsToInt((intBitsToFloat(R8i.z) * intBitsToFloat(backupReg1i) + intBitsToFloat(R127i.y))); +PS1i = R122i.x; +// 18 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R12i.x),intBitsToFloat(R12i.y),intBitsToFloat(PV1i.y),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R124i.y),1.0,0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R126i.z = tempi.x; +R124i.y = floatBitsToInt((intBitsToFloat(R8i.x) * intBitsToFloat(R6i.x) + intBitsToFloat(PS1i))); +PS0i = R124i.y; +// 19 +R123i.x = floatBitsToInt((intBitsToFloat(R125i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R125i.x))); +PV1i.x = R123i.x; +R127i.y = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R126i.x))); +R123i.z = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(R124i.w))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R127i.z))); +PV1i.w = R123i.w; +R127i.x = floatBitsToInt((intBitsToFloat(R125i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(R126i.w))); +PS1i = R127i.x; +// 20 +R8i.x = floatBitsToInt((intBitsToFloat(R124i.y) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV1i.z))); +R8i.y = floatBitsToInt((intBitsToFloat(R124i.y) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV1i.w))); +R123i.w = floatBitsToInt((intBitsToFloat(R125i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(R125i.z))); +PV0i.w = R123i.w; +R6i.x = floatBitsToInt((intBitsToFloat(R126i.z) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV1i.x))); +PS0i = R6i.x; +// 21 +R6i.y = floatBitsToInt((intBitsToFloat(R126i.z) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(R127i.x))); +R8i.z = floatBitsToInt((intBitsToFloat(R124i.y) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(R127i.y))); +R6i.z = floatBitsToInt((intBitsToFloat(R126i.z) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.w))); +PS1i = R6i.z; +// 22 +R7i.z = R13i.z; +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].w) * 1.0); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].y) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].z) * 1.0); +PV0i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[9].x) * 1.0); +R0i.x = 0; +PS0i = R0i.x; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].w) + intBitsToFloat(PV0i.x))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].y) + intBitsToFloat(PV0i.y))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.z) * intBitsToFloat(uf_remappedVS[6].x) + intBitsToFloat(PV0i.w))); +PV1i.w = R123i.w; +R5i.z = R3i.w; +R5i.z = floatBitsToInt(intBitsToFloat(R5i.z) * 2.0); +PS1i = R5i.z; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].w) + intBitsToFloat(PV1i.x))); +PV0i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].y) + intBitsToFloat(PV1i.y))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].z) + intBitsToFloat(PV1i.z))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R2i.y) * intBitsToFloat(uf_remappedVS[7].x) + intBitsToFloat(PV1i.w))); +PV0i.w = R123i.w; +R5i.x = ((0.0 >= intBitsToFloat(PS1i))?int(0xFFFFFFFF):int(0x0)); +PS0i = R5i.x; +// 3 +R126i.x = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].x) + intBitsToFloat(PV0i.w))); +PV1i.x = R126i.x; +R125i.y = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].y) + intBitsToFloat(PV0i.y))); +PV1i.y = R125i.y; +R126i.z = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].z) + intBitsToFloat(PV0i.z))); +PV1i.z = R126i.z; +R0i.w = floatBitsToInt((intBitsToFloat(R2i.x) * intBitsToFloat(uf_remappedVS[8].w) + intBitsToFloat(PV0i.x))); +PV1i.w = R0i.w; +R127i.x = floatBitsToInt((intBitsToFloat(R11i.y) * intBitsToFloat(0x3e22f983) + 0.5)); +PS1i = R127i.x; +// 4 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV1i.x),intBitsToFloat(PV1i.y),intBitsToFloat(PV1i.z),intBitsToFloat(PV1i.w)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R11i.x) * intBitsToFloat(0x3e22f983) + 0.5)); +PS0i = R127i.y; +// 5 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].y) + -(intBitsToFloat(0x3dcccccd))); +PV1i.y = floatBitsToInt(-(intBitsToFloat(R11i.z)) + -(intBitsToFloat(PV0i.x))); +PV1i.z = floatBitsToInt(-(intBitsToFloat(R7i.z)) + intBitsToFloat(uf_remappedVS[11].x)); +PV1i.w = floatBitsToInt(intBitsToFloat(R7i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PS1i = floatBitsToInt(intBitsToFloat(uf_remappedVS[11].w) + -(intBitsToFloat(0x3dcccccd))); +// 6 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.y)) + intBitsToFloat(PV1i.z)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.y) + -(intBitsToFloat(PV1i.w))); +R127i.z = ((intBitsToFloat(PV1i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +R127i.w = ((intBitsToFloat(PS1i) >= 0.0)?(floatBitsToInt(1.0)):(0)); +R126i.y = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[12].w)) + 1.0); +PS0i = R126i.y; +// 7 +PV1i.x = floatBitsToInt(fract(intBitsToFloat(R127i.x))); +R2i.y = ((-(1.0) > intBitsToFloat(uf_remappedVS[0].y))?int(0xFFFFFFFF):int(0x0)); +R123i.z = ((intBitsToFloat(PV0i.y) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.z = R123i.z; +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +PS1i = floatBitsToInt(fract(intBitsToFloat(R127i.y))); +// 8 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.w) * intBitsToFloat(R127i.z)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.z) * intBitsToFloat(R127i.w)); +R123i.z = floatBitsToInt((intBitsToFloat(PV1i.x) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(0x40c90fdb) + -(intBitsToFloat(0x40490fdb)))); +PV0i.w = R123i.w; +R127i.w = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].x) + -(1.0)); +PS0i = R127i.w; +// 9 +R127i.x = floatBitsToInt(intBitsToFloat(PV0i.w) * intBitsToFloat(0x3e22f983)); +PV1i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].y) + -(1.0)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.x) + intBitsToFloat(PV0i.y)); +R126i.w = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x3e22f983)); +PV1i.w = R126i.w; +R127i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[13].z) + -(1.0)); +PS1i = R127i.y; +// 10 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + -(0.0)); +R124i.y = floatBitsToInt(intBitsToFloat(uf_remappedVS[14].x) + -(intBitsToFloat(uf_remappedVS[14].y))); +R0i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R1i.w = floatBitsToInt((intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R124i.x = floatBitsToInt(sin((intBitsToFloat(PV1i.w))/0.1591549367)); +PS0i = R124i.x; +// 11 +R125i.x = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +R5i.y = ((intBitsToFloat(uf_remappedVS[14].x) == intBitsToFloat(uf_remappedVS[14].y))?int(0xFFFFFFFF):int(0x0)); +R1i.z = floatBitsToInt((intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[13].w) + 1.0)); +R123i.w = ((intBitsToFloat(PV0i.x) >= 0.0)?(floatBitsToInt(1.0)):(0)); +PV1i.w = R123i.w; +R127i.y = floatBitsToInt(sin((intBitsToFloat(R127i.x))/0.1591549367)); +PS1i = R127i.y; +// 12 +backupReg0i = R127i.x; +R127i.x = floatBitsToInt(intBitsToFloat(R14i.x) * intBitsToFloat(PV1i.w)); +PV0i.x = R127i.x; +R11i.y = floatBitsToInt(intBitsToFloat(R14i.y) * intBitsToFloat(PV1i.w)); +PV0i.y = R11i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R14i.z) * intBitsToFloat(PV1i.w)); +PV0i.z = R127i.z; +R125i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R127i.w = floatBitsToInt(cos((intBitsToFloat(backupReg0i))/0.1591549367)); +PS0i = R127i.w; +// 13 +backupReg0i = R126i.y; +backupReg0i = R126i.y; +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(R126i.y)); +R126i.y = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS0i)); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(backupReg0i)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(backupReg0i)); +PS1i = floatBitsToInt(cos((intBitsToFloat(R126i.w))/0.1591549367)); +// 14 +R11i.x = floatBitsToInt(intBitsToFloat(R126i.x) + intBitsToFloat(PV1i.w)); +PV0i.x = R11i.x; +R0i.y = floatBitsToInt(intBitsToFloat(R125i.y) + intBitsToFloat(PV1i.z)); +PV0i.y = R0i.y; +R2i.z = floatBitsToInt(intBitsToFloat(R126i.z) + intBitsToFloat(PV1i.x)); +PV0i.z = R2i.z; +R126i.w = floatBitsToInt(intBitsToFloat(R1i.x) * intBitsToFloat(PS1i)); +R122i.x = floatBitsToInt((intBitsToFloat(PS1i) * intBitsToFloat(R1i.y) + intBitsToFloat(R125i.x))); +PS0i = R122i.x; +// 15 +backupReg0i = R0i.w; +R2i.x = floatBitsToInt(dot(vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),intBitsToFloat(uf_remappedVS[2].w)))); +PV1i.x = R2i.x; +PV1i.y = R2i.x; +PV1i.z = R2i.x; +PV1i.w = R2i.x; +R126i.x = floatBitsToInt((intBitsToFloat(R10i.w) * intBitsToFloat(PS0i) + intBitsToFloat(R10i.y))); +PS1i = R126i.x; +// 16 +backupReg0i = R0i.w; +backupReg1i = R126i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R0i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),intBitsToFloat(uf_remappedVS[3].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R10i.y = tempi.x; +R126i.w = floatBitsToInt((-(intBitsToFloat(R124i.x)) * intBitsToFloat(R1i.y) + intBitsToFloat(backupReg1i))); +PS0i = R126i.w; +// 17 +backupReg0i = R0i.y; +backupReg1i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R2i.z),intBitsToFloat(backupReg1i)),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),intBitsToFloat(uf_remappedVS[10].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R11i.z = tempi.x; +R2i.w = floatBitsToInt(1.0 / intBitsToFloat(R124i.y)); +PS1i = R2i.w; +// 18 +backupReg0i = R126i.y; +backupReg1i = R126i.x; +R126i.x = floatBitsToInt(-(intBitsToFloat(PV1i.x)) * intBitsToFloat(0x42800000)); +R126i.y = floatBitsToInt((intBitsToFloat(R10i.z) * intBitsToFloat(R126i.w) + intBitsToFloat(R10i.x))); +R126i.z = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(R1i.y) + intBitsToFloat(R125i.w))); +R123i.w = floatBitsToInt((-(intBitsToFloat(R127i.y)) * intBitsToFloat(R1i.y) + intBitsToFloat(backupReg0i))); +PV0i.w = R123i.w; +R1i.y = floatBitsToInt(intBitsToFloat(backupReg1i) + 0.5); +PS0i = R1i.y; +// 19 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R11i.y),intBitsToFloat(R127i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.y = floatBitsToInt((intBitsToFloat(R9i.z) * intBitsToFloat(PV0i.w) + intBitsToFloat(R9i.x))); +PS1i = R127i.y; +// 20 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R11i.y),intBitsToFloat(R127i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.x = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(0x3a4ccccd)); +PS0i = R127i.x; +// 21 +backupReg0i = R9i.y; +R9i.x = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(0x3ab60b61)); +R9i.y = floatBitsToInt(intBitsToFloat(R126i.x) * intBitsToFloat(uf_remappedVS[12].w)); +PV1i.y = R9i.y; +R9i.z = floatBitsToInt(intBitsToFloat(R126i.y) + 0.5); +R10i.w = floatBitsToInt((intBitsToFloat(R9i.w) * intBitsToFloat(R126i.z) + intBitsToFloat(backupReg0i))); +R7i.x = floatBitsToInt(intBitsToFloat(R127i.y) + 0.5); +PS1i = R7i.x; +// 22 +backupReg0i = R0i.y; +backupReg1i = R0i.w; +R1i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R2i.z),intBitsToFloat(backupReg1i)),vec4(intBitsToFloat(uf_remappedVS[15].x),intBitsToFloat(uf_remappedVS[15].y),intBitsToFloat(uf_remappedVS[15].z),intBitsToFloat(uf_remappedVS[15].w)))); +PV0i.x = R1i.x; +PV0i.y = R1i.x; +PV0i.z = R1i.x; +PV0i.w = R1i.x; +R9i.w = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(R127i.x)); +PS0i = R9i.w; +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +backupReg0i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(R0i.y),intBitsToFloat(R2i.z),intBitsToFloat(backupReg0i)),vec4(intBitsToFloat(uf_remappedVS[16].x),intBitsToFloat(uf_remappedVS[16].y),intBitsToFloat(uf_remappedVS[16].z),intBitsToFloat(uf_remappedVS[16].w)))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +R126i.z = floatBitsToInt(intBitsToFloat(R9i.y) * intBitsToFloat(R9i.x)); +PS0i = R126i.z; +// 1 +backupReg0i = R0i.y; +backupReg1i = R0i.w; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R2i.z),intBitsToFloat(backupReg1i)),vec4(intBitsToFloat(uf_remappedVS[17].x),intBitsToFloat(uf_remappedVS[17].y),intBitsToFloat(uf_remappedVS[17].z),intBitsToFloat(uf_remappedVS[17].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R126i.x = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(R9i.w)); +PS1i = R126i.x; +// 2 +backupReg0i = R1i.y; +R127i.x = ((R2i.y == 0)?(PS1i):(PS1i)); +R1i.y = floatBitsToInt(intBitsToFloat(R10i.w) + 0.5); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedVS[0].z)); +R126i.w = floatBitsToInt(intBitsToFloat(R127i.y) + intBitsToFloat(R126i.z)); +R125i.x = floatBitsToInt(-(intBitsToFloat(backupReg0i)) + 1.0); +PS0i = R125i.x; +// 3 +backupReg0i = R0i.y; +backupReg1i = R0i.w; +backupReg2i = R0i.x; +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R11i.x),intBitsToFloat(backupReg0i),intBitsToFloat(R2i.z),intBitsToFloat(backupReg1i)),vec4(intBitsToFloat(uf_remappedVS[18].x),intBitsToFloat(uf_remappedVS[18].y),intBitsToFloat(uf_remappedVS[18].z),intBitsToFloat(uf_remappedVS[18].w)))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R124i.z = tempi.x; +R127i.y = ((R2i.y == 0)?(PV0i.z):(backupReg2i)); +PS1i = R127i.y; +// 4 +R123i.x = ((R2i.y == 0)?(PV1i.x):(PV1i.x)); +PV0i.x = R123i.x; +R126i.y = floatBitsToInt(-(intBitsToFloat(R11i.z))); +R125i.z = ((intBitsToFloat(uf_remappedVS[14].z) == 0.0)?int(0xFFFFFFFF):int(0x0)); +R123i.w = ((R2i.y == 0)?(R126i.w):(R126i.w)); +PV0i.w = R123i.w; +R0i.x = ((R5i.x == 0)?(R127i.x):(0x3f800000)); +PS0i = R0i.x; +// 5 +backupReg0i = R0i.y; +R1i.x = 0; +R2i.y = ((R5i.x == 0)?(PV0i.w):(0x3f800000)); +R2i.z = ((R5i.x == 0)?(R127i.y):(0x3f800000)); +R0i.w = ((R5i.x == 0)?(PV0i.x):(0x3f800000)); +R0i.y = floatBitsToInt(intBitsToFloat(backupReg0i) + -(intBitsToFloat(uf_remappedVS[14].w))); +PS1i = R0i.y; +// 6 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),-0.0),vec4(intBitsToFloat(R6i.x),intBitsToFloat(R6i.y),intBitsToFloat(R6i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.w = tempi.x; +R7i.z = 0; +PS0i = R7i.z; +// 7 +R127i.x = floatBitsToInt(dot(vec4(intBitsToFloat(R8i.x),intBitsToFloat(R8i.y),intBitsToFloat(R8i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[2].x),intBitsToFloat(uf_remappedVS[2].y),intBitsToFloat(uf_remappedVS[2].z),0.0))); +PV1i.x = R127i.x; +PV1i.y = R127i.x; +PV1i.z = R127i.x; +PV1i.w = R127i.x; +R3i.w = 0; +PS1i = R3i.w; +// 8 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R8i.x),intBitsToFloat(R8i.y),intBitsToFloat(R8i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[3].x),intBitsToFloat(uf_remappedVS[3].y),intBitsToFloat(uf_remappedVS[3].z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = tempi.x; +tempResultf = 1.0 / sqrt(intBitsToFloat(R127i.w)); +R126i.z = floatBitsToInt(tempResultf); +PS0i = R126i.z; +// 9 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R8i.x),intBitsToFloat(R8i.y),intBitsToFloat(R8i.z),-0.0),vec4(intBitsToFloat(uf_remappedVS[10].x),intBitsToFloat(uf_remappedVS[10].y),intBitsToFloat(uf_remappedVS[10].z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R127i.z = tempi.x; +R124i.x = floatBitsToInt(intBitsToFloat(R6i.x) * intBitsToFloat(PS0i)); +PS1i = R124i.x; +// 10 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV1i.x),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV1i.x),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.y = floatBitsToInt(intBitsToFloat(R6i.y) * intBitsToFloat(R126i.z)); +PS0i = R127i.y; +// 11 +R6i.x = ((R125i.z == 0)?(R1i.x):(R126i.x)); +R6i.y = ((R125i.z == 0)?(R0i.y):(R126i.w)); +PV1i.z = floatBitsToInt(intBitsToFloat(R6i.z) * intBitsToFloat(R126i.z)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 12 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R124i.x),intBitsToFloat(R127i.y),intBitsToFloat(PV1i.z),-0.0),vec4(-(intBitsToFloat(uf_remappedVS[19].x)),-(intBitsToFloat(uf_remappedVS[19].y)),-(intBitsToFloat(uf_remappedVS[19].z)),0.0))); +tempi.x = floatBitsToInt(intBitsToFloat(tempi.x) / 2.0); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +PS0i = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +// 13 +PV1i.x = floatBitsToInt(max(intBitsToFloat(PS0i), -(intBitsToFloat(PS0i)))); +R7i.y = floatBitsToInt(-(intBitsToFloat(R1i.y)) + 1.0); +R6i.z = ((R125i.z == 0)?(R7i.z):(R126i.y)); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) + 0.5); +R6i.w = ((R125i.z == 0)?(R3i.w):(R124i.z)); +PS1i = R6i.w; +// 14 +PV0i.x = floatBitsToInt(max(intBitsToFloat(PV1i.w), 0.0)); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.x) + -(intBitsToFloat(uf_remappedVS[14].y))); +R7i.w = R125i.x; +R7i.z = R9i.z; +PS0i = R7i.z; +// 15 +R123i.x = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[20].y) + intBitsToFloat(R1i.w))); +PV1i.x = R123i.x; +R123i.y = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[20].x) + intBitsToFloat(R0i.z))); +PV1i.y = R123i.y; +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(R2i.w)); +R123i.w = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[20].z) + intBitsToFloat(R1i.z))); +PV1i.w = R123i.w; +// 16 +R123i.x = ((R5i.y == 0)?(PV1i.z):(0x3f800000)); +PV0i.x = R123i.x; +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + -(1.0)); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.y) + -(1.0)); +PV0i.w = floatBitsToInt(intBitsToFloat(PV1i.w) + -(1.0)); +// 17 +R1i.x = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.x = R1i.x; +R0i.y = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.y = R0i.y; +R0i.z = floatBitsToInt((intBitsToFloat(PV0i.w) * intBitsToFloat(uf_remappedVS[20].w) + 1.0)); +PV1i.z = R0i.z; +R1i.z = PV0i.x; +R1i.z = clampFI32(R1i.z); +PS1i = R1i.z; +// 18 +backupReg0i = R3i.x; +backupReg1i = R3i.z; +R3i.x = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV1i.x)); +R1i.y = floatBitsToInt(intBitsToFloat(R3i.y) * intBitsToFloat(PV1i.y)); +R3i.z = floatBitsToInt(intBitsToFloat(backupReg1i) * intBitsToFloat(PV1i.z)); +// 19 +predResult = (intBitsToFloat(uf_remappedVS[11].y) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(-(intBitsToFloat(R11i.z)) + -(intBitsToFloat(uf_remappedVS[11].x))); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].x)) + intBitsToFloat(uf_remappedVS[11].y)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R5i.z; +R5i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +predResult = (intBitsToFloat(uf_remappedVS[11].w) > 0.0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R127i.z = floatBitsToInt(intBitsToFloat(R11i.z) + intBitsToFloat(uf_remappedVS[11].w)); +PV0i.w = floatBitsToInt(-(intBitsToFloat(uf_remappedVS[11].z)) + intBitsToFloat(uf_remappedVS[11].w)); +// 1 +PS1i = floatBitsToInt(1.0 / intBitsToFloat(PV0i.w)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.z) * intBitsToFloat(PS1i)); +PV0i.x = clampFI32(PV0i.x); +// 3 +backupReg0i = R5i.z; +R5i.z = floatBitsToInt(intBitsToFloat(backupReg0i) * intBitsToFloat(PV0i.x)); +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = floatBitsToInt(-(intBitsToFloat(R11i.z)) + -(intBitsToFloat(uf_remappedVS[21].x))); +R126i.y = floatBitsToInt(intBitsToFloat(R4i.x) * intBitsToFloat(R1i.x)); +R126i.z = floatBitsToInt(intBitsToFloat(R4i.y) * intBitsToFloat(R0i.y)); +PV0i.w = ((0.0 >= intBitsToFloat(uf_remappedVS[0].w))?int(0xFFFFFFFF):int(0x0)); +R127i.w = floatBitsToInt(intBitsToFloat(R4i.z) * intBitsToFloat(R0i.z)); +PS0i = R127i.w; +// 1 +R4i.x = ((PV0i.w == 0)?(R0i.x):(0x3f800000)); +R4i.y = ((PV0i.w == 0)?(R2i.y):(0x3f800000)); +R4i.z = ((PV0i.w == 0)?(R2i.z):(0x3f800000)); +R4i.w = ((PV0i.w == 0)?(R0i.w):(0x3f800000)); +PS1i = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedVS[21].y)); +// 2 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(R2i.x),intBitsToFloat(R10i.y),intBitsToFloat(R11i.z),-0.0),vec4(intBitsToFloat(R2i.x),intBitsToFloat(R10i.y),intBitsToFloat(R11i.z),0.0))); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +R127i.z = floatBitsToInt(max(intBitsToFloat(PS1i), 0.0)); +PS0i = R127i.z; +// 3 +R0i.x = floatBitsToInt(max(intBitsToFloat(R3i.x), 0.0)); +R0i.y = floatBitsToInt(max(intBitsToFloat(R1i.y), 0.0)); +R0i.w = floatBitsToInt(intBitsToFloat(R1i.z) * intBitsToFloat(R5i.z)); +tempResultf = 1.0 / sqrt(intBitsToFloat(PV0i.x)); +PS1i = floatBitsToInt(tempResultf); +// 4 +backupReg0i = R127i.z; +R127i.x = floatBitsToInt(intBitsToFloat(R2i.x) * intBitsToFloat(PS1i)); +PV0i.x = R127i.x; +R125i.y = floatBitsToInt(intBitsToFloat(R10i.y) * intBitsToFloat(PS1i)); +PV0i.y = R125i.y; +R127i.z = floatBitsToInt(intBitsToFloat(R11i.z) * intBitsToFloat(PS1i)); +PV0i.z = R127i.z; +tempResultf = log2(intBitsToFloat(backupReg0i)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +R127i.y = floatBitsToInt(tempResultf); +PS0i = R127i.y; +// 5 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[22].x),intBitsToFloat(uf_remappedVS[22].y),intBitsToFloat(uf_remappedVS[22].z),-0.0),vec4(intBitsToFloat(PV0i.x),intBitsToFloat(PV0i.y),intBitsToFloat(PV0i.z),0.0))); +PV1i.x = tempi.x; +PV1i.y = tempi.x; +PV1i.z = tempi.x; +PV1i.w = tempi.x; +R0i.z = floatBitsToInt(max(intBitsToFloat(R3i.z), 0.0)); +PS1i = R0i.z; +// 6 +PV0i.x = floatBitsToInt(intBitsToFloat(R127i.y) * intBitsToFloat(uf_remappedVS[21].z)); +R2i.y = floatBitsToInt(max(intBitsToFloat(R126i.z), 0.0)); +R2i.z = floatBitsToInt(max(intBitsToFloat(R127i.w), 0.0)); +PV0i.w = floatBitsToInt(max(intBitsToFloat(PV1i.x), -(intBitsToFloat(PV1i.x)))); +R2i.x = floatBitsToInt(max(intBitsToFloat(R126i.y), 0.0)); +PS0i = R2i.x; +// 7 +PV1i.x = floatBitsToInt(intBitsToFloat(uf_remappedVS[23].z) * intBitsToFloat(R127i.z)); +PV1i.z = floatBitsToInt(-(intBitsToFloat(PV0i.w)) + 1.0); +R127i.z = floatBitsToInt(exp2(intBitsToFloat(PV0i.x))); +PS1i = R127i.z; +// 8 +tempi.x = floatBitsToInt(dot(vec4(intBitsToFloat(uf_remappedVS[23].x),intBitsToFloat(uf_remappedVS[23].y),intBitsToFloat(PV1i.x),-0.0),vec4(intBitsToFloat(R127i.x),intBitsToFloat(R125i.y),1.0,0.0))); +tempi.x = clampFI32(tempi.x); +PV0i.x = tempi.x; +PV0i.y = tempi.x; +PV0i.z = tempi.x; +PV0i.w = tempi.x; +tempResultf = log2(intBitsToFloat(PV1i.z)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS0i = floatBitsToInt(tempResultf); +// 9 +PV1i.x = floatBitsToInt(intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].w)); +PV1i.y = floatBitsToInt(min(intBitsToFloat(R127i.z), 1.0)); +tempResultf = log2(intBitsToFloat(PV0i.x)); +if( isinf(tempResultf) == true ) tempResultf = -3.40282347E+38F; +PS1i = floatBitsToInt(tempResultf); +// 10 +R127i.x = floatBitsToInt(intBitsToFloat(PV1i.y) * intBitsToFloat(uf_remappedVS[21].w)); +PV0i.y = floatBitsToInt(intBitsToFloat(PS1i) * intBitsToFloat(uf_remappedVS[25].w)); +R127i.w = floatBitsToInt(exp2(intBitsToFloat(PV1i.x))); +PS0i = R127i.w; +// 11 +R125i.y = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].y) + intBitsToFloat(uf_remappedVS[26].y))); +R127i.z = floatBitsToInt((intBitsToFloat(PS0i) * intBitsToFloat(uf_remappedVS[24].x) + intBitsToFloat(uf_remappedVS[26].x))); +R126i.w = floatBitsToInt(exp2(intBitsToFloat(PV0i.y))); +PS1i = R126i.w; +// 12 +R123i.x = floatBitsToInt((intBitsToFloat(R127i.w) * intBitsToFloat(uf_remappedVS[24].z) + intBitsToFloat(uf_remappedVS[26].z))); +PV0i.x = R123i.x; +// 13 +R1i.x = floatBitsToInt((intBitsToFloat(R126i.w) * intBitsToFloat(uf_remappedVS[25].x) + intBitsToFloat(R127i.z))); +R1i.y = floatBitsToInt((intBitsToFloat(R126i.w) * intBitsToFloat(uf_remappedVS[25].y) + intBitsToFloat(R125i.y))); +R1i.z = floatBitsToInt((intBitsToFloat(R126i.w) * intBitsToFloat(uf_remappedVS[25].z) + intBitsToFloat(PV0i.x))); +// 14 +R1i.w = floatBitsToInt(intBitsToFloat(R127i.x) * intBitsToFloat(uf_remappedVS[19].w)); +} +// export +float origRatio = 1.777f; +float newRatio = 2.370f; +// *(origRatio / newRatio) +gl_Position = vec4(intBitsToFloat(R4i.x)*(origRatio / newRatio), intBitsToFloat(R4i.y), intBitsToFloat(R4i.z), intBitsToFloat(R4i.w)); +// export +passParameterSem0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +// export +passParameterSem2 = vec4(intBitsToFloat(R1i.x), intBitsToFloat(R1i.y), intBitsToFloat(R1i.z), intBitsToFloat(R1i.w)); +// export +// skipped export to semanticId 255 +// export +passParameterSem4 = vec4(intBitsToFloat(R7i.x), intBitsToFloat(R7i.y), intBitsToFloat(R7i.z), intBitsToFloat(R7i.w)); +// export +passParameterSem1 = vec4(intBitsToFloat(R2i.x), intBitsToFloat(R2i.y), intBitsToFloat(R2i.z), intBitsToFloat(R2i.w)); +if( activeMaskStackC[1] == true ) { +// 0 +} +} diff --git a/Enhancement/XenobladeX_219_GUI/rules.txt b/Enhancement/XenobladeX_219_GUI/rules.txt new file mode 100644 index 00000000..3f32290e --- /dev/null +++ b/Enhancement/XenobladeX_219_GUI/rules.txt @@ -0,0 +1,4 @@ +[Definition] +titleIds = 0005000010116100,00050000101C4C00,00050000101C4D00 +name = "Xenoblade Chronicles X - 21:9 GUI and 2d elements " +version = 2 From 5ad576f57d97387a94d19ff1f6fe1464a56c2575 Mon Sep 17 00:00:00 2001 From: getdls Date: Tue, 14 Nov 2017 01:25:45 +0100 Subject: [PATCH 6/7] [XCX} Cut scene shadow scaling Scales shadows to resolution.. x2 scaling is a good compromise until extra edge smoothing has been implemented --- .../af7acf7fb6dca1be_0000000000079249_ps.txt | 585 ++++++++++++++++++ 1 file changed, 585 insertions(+) create mode 100644 Source/XenobladeX/af7acf7fb6dca1be_0000000000079249_ps.txt diff --git a/Source/XenobladeX/af7acf7fb6dca1be_0000000000079249_ps.txt b/Source/XenobladeX/af7acf7fb6dca1be_0000000000079249_ps.txt new file mode 100644 index 00000000..2914aedd --- /dev/null +++ b/Source/XenobladeX/af7acf7fb6dca1be_0000000000079249_ps.txt @@ -0,0 +1,585 @@ + + +#version 420 +#extension GL_ARB_texture_gather : enable +// shader af7acf7fb6dca1be +//cutscene shadow scaling +//to do - extra edge smooth pass, +//const float resScale = 2.0;// 2.0 looks good +const float resScale = ; +uniform ivec4 uf_remappedPS[31]; +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 0xf599a000 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 0xf551a000 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 0xf571a000 res 1024x1024x1 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(binding = 4) uniform sampler2DShadow textureUnitPS4;// Tex4 addr 0xf591a000 res 512x512x1 dim 1 tm: 4 format 0005 compSel: 0 4 4 5 mipView: 0x0 (num 0x1) sliceView: 0x0 (num 0x1) Sampler4 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)); +R5i.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)); +R6i.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(R6i.y) * intBitsToFloat(uf_remappedPS[4].y) + intBitsToFloat(PV1i.w))); +R127i.y = floatBitsToInt((intBitsToFloat(R6i.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(R5i.y))); +// 5 +R126i.y = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].z) + intBitsToFloat(R5i.z))); +R126i.w = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[4].z) + intBitsToFloat(R127i.z))); +// 6 +backupReg0i = R127i.x; +backupReg1i = R127i.y; +backupReg2i = R127i.w; +R127i.x = floatBitsToInt((intBitsToFloat(R6i.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(R6i.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(R6i.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))); +R0i.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)); +R7i.y = floatBitsToInt(max(intBitsToFloat(R126i.y), -(intBitsToFloat(R126i.y)))); +PS1i = R7i.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); //distant shadow +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(R0i.y) + intBitsToFloat(uf_remappedPS[13].y) / resScale); +PS1i = R4i.y; +} +if( activeMaskStackC[1] == true ) { +R7i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R0i.xz), intBitsToFloat(R0i.w)))); +R1i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R1i.xy), intBitsToFloat(R1i.w)))); +R9i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R2i.zy), intBitsToFloat(R2i.w)))); +R10i.x = floatBitsToInt(texture(textureUnitPS2, vec3(intBitsToFloat(R3i.xy), intBitsToFloat(R3i.w)))); +R0i.x = floatBitsToInt(texture(textureUnitPS4, vec3(intBitsToFloat(R4i.zy), intBitsToFloat(R4i.w)))); +} +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +R8i.x = floatBitsToInt(intBitsToFloat(uf_remappedPS[14].x) * 1.0); +PV0i.x = R8i.x; +R4i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[14].y) * 1.0); +PV0i.y = R4i.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(R6i.y) * intBitsToFloat(uf_remappedPS[16].x) + intBitsToFloat(PV1i.w))); +PV0i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[16].z) + intBitsToFloat(PV1i.x))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R6i.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(R7i.x) + intBitsToFloat(R1i.x)); +R0i.w = floatBitsToInt(max(intBitsToFloat(R2i.x), intBitsToFloat(R7i.y))); +// 1 +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R9i.x)); +// 2 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.y) + intBitsToFloat(R10i.x)); +// 3 +R6i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * 0.25); +// 4 +predResult = (intBitsToFloat(R0i.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 +R1i.xyz = floatBitsToInt(vec3(intBitsToFloat(R3i.x),intBitsToFloat(R3i.y),intBitsToFloat(R0i.z)) + vec3(intBitsToFloat(uf_remappedPS[18].x),intBitsToFloat(uf_remappedPS[18].y),intBitsToFloat(uf_remappedPS[18].z))); +PV0i.z = R1i.z; +// 1 +R7i.x = floatBitsToInt(intBitsToFloat(R3i.x) + intBitsToFloat(uf_remappedPS[19].x)); +R7i.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; +R1i.w = PV0i.z; +R1i.w = clampFI32(R1i.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; +R7i.w = PV1i.z; +R7i.w = clampFI32(R7i.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(textureUnitPS3, vec3(intBitsToFloat(R1i.xy), intBitsToFloat(R1i.w)))); +R0i.x = floatBitsToInt(texture(textureUnitPS3, vec3(intBitsToFloat(R7i.xy), intBitsToFloat(R7i.w)))); +R2i.x = floatBitsToInt(texture(textureUnitPS3, vec3(intBitsToFloat(R2i.xy), intBitsToFloat(R2i.w)))); +R3i.x = floatBitsToInt(texture(textureUnitPS3, 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(R0i.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(R6i.w)))); +PV1i.x = R123i.x; +// 4 +backupReg0i = R6i.w; +R6i.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(R4i.y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[15].x) + intBitsToFloat(R8i.x))); +PV0i.w = R123i.w; +// 1 +R123i.x = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[16].x) + intBitsToFloat(PV0i.w))); +PV1i.x = R123i.x; +R123i.z = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[16].z) + intBitsToFloat(PV0i.y))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[16].y) + intBitsToFloat(PV0i.z))); +PV1i.w = R123i.w; +// 2 +R1i.x = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[17].x) + intBitsToFloat(PV1i.x))); +PV0i.x = R1i.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 +R2i.x = floatBitsToInt(max(intBitsToFloat(PV1i.w), -(intBitsToFloat(PV1i.w)))); +PV0i.x = R2i.x; +R1i.y = floatBitsToInt(max(intBitsToFloat(PV1i.z), -(intBitsToFloat(PV1i.z)))); +PV0i.y = R1i.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)); +R7i.w = floatBitsToInt(max(intBitsToFloat(R2i.x), intBitsToFloat(R1i.y))); +// 1 +R0i.x = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(uf_remappedPS[19].x)); +R0i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[19].y)); +R1i.z = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(uf_remappedPS[18].x)); +R0i.w = PV0i.z; +R0i.w = clampFI32(R0i.w); +R1i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[18].y)); +PS1i = R1i.y; +// 2 +backupReg0i = R0i.z; +R2i.x = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(uf_remappedPS[20].x)); +R2i.y = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[20].y)); +PV0i.z = floatBitsToInt(intBitsToFloat(backupReg0i) + intBitsToFloat(uf_remappedPS[20].z)); +R1i.w = R127i.x; +R1i.w = clampFI32(R1i.w); +// 3 +R3i.x = floatBitsToInt(intBitsToFloat(R1i.x) + intBitsToFloat(uf_remappedPS[21].x)); +PV1i.y = floatBitsToInt(intBitsToFloat(R0i.z) + intBitsToFloat(uf_remappedPS[21].z)); +R3i.z = floatBitsToInt(intBitsToFloat(R3i.y) + intBitsToFloat(uf_remappedPS[21].y)); +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(textureUnitPS3, vec3(intBitsToFloat(R0i.xy), intBitsToFloat(R0i.w)))); +R1i.x = floatBitsToInt(texture(textureUnitPS3, vec3(intBitsToFloat(R1i.zy), intBitsToFloat(R1i.w)))); +R2i.x = floatBitsToInt(texture(textureUnitPS3, vec3(intBitsToFloat(R2i.xy), intBitsToFloat(R2i.w)))); +R3i.x = floatBitsToInt(texture(textureUnitPS3, 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 +R6i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * 0.25); +// 4 +predResult = (intBitsToFloat(R7i.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; +R4i.y = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].y) + intBitsToFloat(R5i.y))); +PV0i.y = R4i.y; +R0i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[5].z) + intBitsToFloat(R5i.z))); +PV0i.z = R0i.z; +// 1 +R4i.x = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[6].x) + intBitsToFloat(PV0i.x))); +PV1i.x = R4i.x; +R4i.y = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[6].y) + intBitsToFloat(PV0i.y))); +PV1i.y = R4i.y; +R0i.z = floatBitsToInt((intBitsToFloat(R6i.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; +R4i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[8].y) + intBitsToFloat(PV1i.y))); +PV0i.y = R4i.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(textureUnitPS4, vec3(intBitsToFloat(R4i.xy), intBitsToFloat(R4i.w)))); +} +if( activeMaskStackC[4] == true ) { +// 0 +R127i.x = floatBitsToInt(-(intBitsToFloat(R6i.w)) + intBitsToFloat(R0i.x)); +PV0i.z = floatBitsToInt(intBitsToFloat(R7i.w) + -(intBitsToFloat(0x3eae147b))); +// 1 +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(0x40c80000)); +// 2 +backupReg0i = R6i.w; +R6i.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(R0i.x)) + 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(R0i.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 +R6i.w = floatBitsToInt((intBitsToFloat(R127i.x) * intBitsToFloat(PV0i.y) + intBitsToFloat(R0i.x))); +} +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +activeMaskStack[1] = activeMaskStack[0]; +activeMaskStackC[2] = activeMaskStackC[1]; +// 0 +PV0i.x = floatBitsToInt(intBitsToFloat(uf_remappedPS[22].z) * 1.0); +PV0i.y = floatBitsToInt(intBitsToFloat(uf_remappedPS[22].y) * 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(uf_remappedPS[22].x) * 1.0); +// 1 +R123i.y = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[23].z) + intBitsToFloat(PV0i.x))); +PV1i.y = R123i.y; +R123i.z = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[23].y) + intBitsToFloat(PV0i.y))); +PV1i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R5i.w) * intBitsToFloat(uf_remappedPS[23].x) + intBitsToFloat(PV0i.z))); +PV1i.w = R123i.w; +// 2 +R123i.x = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[24].x) + intBitsToFloat(PV1i.w))); +PV0i.x = R123i.x; +R123i.z = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[24].z) + intBitsToFloat(PV1i.y))); +PV0i.z = R123i.z; +R123i.w = floatBitsToInt((intBitsToFloat(R6i.y) * intBitsToFloat(uf_remappedPS[24].y) + intBitsToFloat(PV1i.z))); +PV0i.w = R123i.w; +// 3 +R1i.x = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[25].x) + intBitsToFloat(PV0i.x))); +PV1i.x = R1i.x; +R1i.y = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[25].y) + intBitsToFloat(PV0i.w))); +PV1i.y = R1i.y; +R2i.z = floatBitsToInt((intBitsToFloat(R5i.x) * intBitsToFloat(uf_remappedPS[25].z) + intBitsToFloat(PV0i.z))); +// 4 +PV0i.x = floatBitsToInt(intBitsToFloat(PV1i.y) + -(0.5)); +PV0i.y = floatBitsToInt(intBitsToFloat(PV1i.x) + -(0.5)); +// 5 +PV1i.z = floatBitsToInt(max(intBitsToFloat(PV0i.x), -(intBitsToFloat(PV0i.x)))); +PV1i.w = floatBitsToInt(max(intBitsToFloat(PV0i.y), -(intBitsToFloat(PV0i.y)))); +// 6 +PV0i.x = ((0.5 > intBitsToFloat(PV1i.z))?int(0xFFFFFFFF):int(0x0)); +PV0i.y = ((0.5 > intBitsToFloat(PV1i.w))?int(0xFFFFFFFF):int(0x0)); +// 7 +R0i.w = ((PV0i.y == 0)?(0):(PV0i.x)); +// 8 +predResult = (R0i.w != 0); +activeMaskStack[1] = predResult; +activeMaskStackC[2] = predResult == true && activeMaskStackC[1] == true; +} +else { +activeMaskStack[1] = false; +activeMaskStackC[2] = false; +} +if( activeMaskStackC[2] == true ) { +// 0 +R0i.xyz = floatBitsToInt(vec3(intBitsToFloat(R1i.x),intBitsToFloat(R1i.y),intBitsToFloat(R1i.x)) + vec3(intBitsToFloat(uf_remappedPS[26].x) / resScale,intBitsToFloat(uf_remappedPS[26].y) / resScale,intBitsToFloat(uf_remappedPS[27].x) / resScale)); +R0i.w = floatBitsToInt(intBitsToFloat(R1i.y) + intBitsToFloat(uf_remappedPS[27].y)/ resScale); // +// 1 +backupReg0i = R1i.x; +backupReg1i = R1i.y; +backupReg0i = R1i.x; +backupReg1i = R1i.y; +R1i.xyz = floatBitsToInt(vec3(intBitsToFloat(backupReg0i),intBitsToFloat(backupReg1i),intBitsToFloat(backupReg0i)) + vec3(intBitsToFloat(uf_remappedPS[28].x) / resScale,intBitsToFloat(uf_remappedPS[28].y) / resScale,intBitsToFloat(uf_remappedPS[29].x) / resScale)); +R1i.w = floatBitsToInt(intBitsToFloat(backupReg1i) + intBitsToFloat(uf_remappedPS[29].y) / resScale); // +} +if( activeMaskStackC[2] == true ) { +R0i.x = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R0i.xy)).x); +R2i.x = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R0i.zw)).x); +R1i.x = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R1i.xy)).x); +R3i.x = floatBitsToInt(texture(textureUnitPS1, intBitsToFloat(R1i.zw)).x); +} +if( activeMaskStackC[2] == true ) { +// 0 +backupReg0i = R0i.x; +PV0i.x = floatBitsToInt(intBitsToFloat(R2i.z) + -(intBitsToFloat(R1i.x))); +PV0i.y = floatBitsToInt(intBitsToFloat(R2i.z) + -(intBitsToFloat(backupReg0i))); +PV0i.z = floatBitsToInt(intBitsToFloat(R2i.z) + -(intBitsToFloat(R2i.x))); +// 1 +PV1i.x = floatBitsToInt(intBitsToFloat(R2i.z) + -(intBitsToFloat(R3i.x))); +PV1i.y = floatBitsToInt(intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedPS[26].w)); +PV1i.y = clampFI32(PV1i.y); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedPS[26].w)); +PV1i.z = clampFI32(PV1i.z); +PV1i.w = floatBitsToInt(intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedPS[26].w)); +PV1i.w = clampFI32(PV1i.w); +// 2 +PV0i.x = floatBitsToInt(-(intBitsToFloat(PV1i.y)) + 1.0); +R127i.y = floatBitsToInt(-(intBitsToFloat(PV1i.w)) + 1.0); +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.x) * intBitsToFloat(uf_remappedPS[26].w)); +PV0i.z = clampFI32(PV0i.z); +PV0i.w = floatBitsToInt(-(intBitsToFloat(PV1i.z)) + 1.0); +// 3 +R126i.y = floatBitsToInt(-(intBitsToFloat(PV0i.z)) + 1.0); +PV1i.z = floatBitsToInt(intBitsToFloat(PV0i.w) + intBitsToFloat(PV0i.x)); +// 4 +PV0i.z = floatBitsToInt(intBitsToFloat(PV1i.z) + intBitsToFloat(R127i.y)); +// 5 +PV1i.x = floatBitsToInt(intBitsToFloat(PV0i.z) + intBitsToFloat(R126i.y)); +// 6 +R0i.w = floatBitsToInt(intBitsToFloat(PV1i.x) * 0.25); +} +activeMaskStack[1] = activeMaskStack[1] == false; +activeMaskStackC[2] = activeMaskStack[1] == true && activeMaskStackC[1] == true; +if( activeMaskStackC[2] == true ) { +// 0 +R0i.w = 0x3f800000; +} +activeMaskStackC[1] = activeMaskStack[0] == true && activeMaskStackC[0] == true; +if( activeMaskStackC[1] == true ) { +// 0 +PV0i.x = R6i.w; +PV0i.y = R0i.w; +PV0i.z = floatBitsToInt(intBitsToFloat(R6i.w) * intBitsToFloat(R0i.w)); +R0i.w = 0; +// 1 +R0i.x = floatBitsToInt((intBitsToFloat(PV0i.z) * intBitsToFloat(uf_remappedPS[30].x) + intBitsToFloat(uf_remappedPS[30].y))); +R0i.y = floatBitsToInt((intBitsToFloat(PV0i.y) * intBitsToFloat(uf_remappedPS[30].x) + intBitsToFloat(uf_remappedPS[30].y))); +R0i.z = floatBitsToInt((intBitsToFloat(PV0i.x) * intBitsToFloat(uf_remappedPS[30].x) + intBitsToFloat(uf_remappedPS[30].y))); +} +// export +passPixelColor0 = vec4(intBitsToFloat(R0i.x), intBitsToFloat(R0i.y), intBitsToFloat(R0i.z), intBitsToFloat(R0i.w)); +} From 6e8f805d5870be7db4fab3595bcac0875f9fd6ea Mon Sep 17 00:00:00 2001 From: Rajko Stojadinovic Date: Tue, 14 Nov 2017 23:48:30 +0100 Subject: [PATCH 7/7] Update BOTW UW patches.txt for 1.3.3 --- Source/BreathOfTheWild/patches.txt | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/Source/BreathOfTheWild/patches.txt b/Source/BreathOfTheWild/patches.txt index 84ffc7e8..2bd178ae 100644 --- a/Source/BreathOfTheWild/patches.txt +++ b/Source/BreathOfTheWild/patches.txt @@ -104,3 +104,19 @@ _aspectAddr = 0x1019F9A8 # 3d aspect (calculated every frame) 0x03726E18 = lis r28, ha16(_aspectAddr) 0x03726E1C = lfs f12, _aspectAddr(r28) + +[BotwAspectsV144] +moduleMatches = 0x9A2CA0C7 +# rodata constants +0x101A8A70 = .float +0x102ECFD0 = .float +0x1034F6CC = .float +_aspectAddr = 0x101A8A70 + +# menu link aspect (calculated every load) +0x02D53CF4 = lis r9, _aspectAddr@ha +0x02D2FD08 = lfs f4, _aspectAddr@l(r9) + +# 3d aspect (calculated every frame) +0x0375B128 = lis r28, ha16(_aspectAddr) +0x0375B12C = lfs f12, _aspectAddr(r28) \ No newline at end of file