Attachment 140691 Details for Bug 107276 – One of the affected shaders (GLSL version)

One of the affected shaders (GLSL version)

fc5.vert (text/plain), 16.75 KB, created by Philip Rebohle on 2018-07-18 13:30:47 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Philip Rebohle

Created: 2018-07-18 13:30:47 UTC

Size: 16.75 KB

patch

obsolete

>#version 450
>
>layout(constant_id = 0) const bool cb0_bound = true;
>layout(constant_id = 1) const bool cb1_bound = true;
>layout(constant_id = 2) const bool cb2_bound = true;
>layout(constant_id = 3) const bool cb3_bound = true;
>layout(constant_id = 4) const bool cb4_bound = true;
>layout(constant_id = 5) const bool cb5_bound = true;
>layout(constant_id = 8) const bool t0_bound = true;
>layout(constant_id = 9) const bool t1_bound = true;
>layout(constant_id = 10) const bool t2_bound = true;
>layout(constant_id = 11) const bool t3_bound = true;
>layout(constant_id = 12) const bool t4_bound = true;
>layout(constant_id = 13) const bool t5_bound = true;
>layout(constant_id = 14) const bool t6_bound = true;
>
>layout(set = 0, binding = 0, std140) uniform struct_cb0 { vec4 m[53]; } cb0;
>layout(set = 0, binding = 1, std140) uniform struct_cb1 { vec4 m[2]; } cb1;
>layout(set = 0, binding = 2, std140) uniform struct_cb2 { vec4 m[4]; } cb2;
>layout(set = 0, binding = 3, std140) uniform struct_cb3 { vec4 m[1]; } cb3;
>layout(set = 0, binding = 4, std140) uniform struct_cb4 { vec4 m[6]; } cb4;
>layout(set = 0, binding = 5, std140) uniform struct_cb5 { vec4 m[3]; } cb5;
>
>layout(set = 0, binding = 6) uniform sampler s0;
>layout(set = 0, binding = 7) uniform sampler s1;
>layout(set = 0, binding = 8) uniform usamplerBuffer t0;
>layout(set = 0, binding = 9) uniform usamplerBuffer t1;
>layout(set = 0, binding = 10) uniform usamplerBuffer t2;
>layout(set = 0, binding = 11) uniform usamplerBuffer t3;
>layout(set = 0, binding = 12) uniform texture2DArray t4;
>layout(set = 0, binding = 13) uniform texture2DArray t5;
>layout(set = 0, binding = 14) uniform usamplerBuffer t6;
>
>layout(location = 0) in ivec4 v0;
>layout(location = 1) in ivec2 v1;
>layout(location = 2) in ivec2 v2;
>layout(location = 3) in vec4 v3;
>layout(location = 4) in uvec4 v4;
>layout(location = 5) in vec4 v5;
>layout(location = 0) out vec4 o0;
>layout(location = 1) out vec3 o1;
>layout(location = 2) out vec3 o2;
>layout(location = 3) out vec4 o3;
>layout(location = 4) out vec3 o4;
>layout(location = 5) out vec3 o5;
>layout(location = 6) out uvec2 o6;
>vec4 shader_in[32];
>vec4 r0;
>vec4 r1;
>vec4 r2;
>vec4 r3;
>vec4 r4;
>vec4 r5;
>vec4 r6;
>vec4 r7;
>vec4 r8;
>vec4 r9;
>vec4 r10;
>vec4 r11;
>vec4 r12;
>vec4 r13;
>vec4 r14;
>vec4 r15;
>
>void vs_main() {
>    r0.x = intBitsToFloat(floatBitsToInt(shader_in[7].x) + floatBitsToInt(cb3.m[0].x));
>    r0.y = uintBitsToFloat(texelFetch(t1, ((floatBitsToInt(r0.x) * 8) + (int(16u) / 4)) + 0).x);
>    int _157 = (floatBitsToInt(r0.x) * 8) + (int(0u) / 4);
>    r0.xzw = uintBitsToFloat(uvec3(
>      texelFetch(t1, _157 + 0).x,
>      texelFetch(t1, _157 + 1).x,
>      texelFetch(t1, _157 + 2).x));
>    r1.xy = intBitsToFloat(floatBitsToInt(r0.yy) + floatBitsToInt(shader_in[4].xy));
>    r1.xy = intBitsToFloat(floatBitsToInt(r1.xy) + ivec2(uvec2(1u)));
>    r1.zw = intBitsToFloat(floatBitsToInt(r1.xy) << ivec2(uvec2(1u)));
>    ivec2 _206 = ivec2(uvec2(31u));
>    ivec2 _207 = ivec2(uvec2(1u));
>    uvec2 _210 = floatBitsToUint(r1.xy);
>    r1.xy = uintBitsToFloat(uvec2(
>      bitfieldInsert(uvec2(1u).x, _210.x, _207.x, _206.x),
>      bitfieldInsert(uvec2(1u).y, _210.y, _207.y, _206.y)));
>    int _231 = (floatBitsToInt(r1.z) * 8) + (int(0u) / 4);
>    r2 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _231 + 0).x,
>      texelFetch(t2, _231 + 1).x,
>      texelFetch(t2, _231 + 2).x,
>      texelFetch(t2, _231 + 3).x));
>    r3 = uintBitsToFloat(floatBitsToUint(r2) & uvec4(65535u));
>    r2 = uintBitsToFloat(floatBitsToUint(r2) >> uvec4(16u));
>    uvec4 _260 = floatBitsToUint(r2);
>    r2 = vec4(
>      unpackHalf2x16(_260.x).x,
>      unpackHalf2x16(_260.y).x,
>      unpackHalf2x16(_260.z).x,
>      unpackHalf2x16(_260.w).x);
>    uvec4 _276 = floatBitsToUint(r3.xzyw);
>    r3 = vec4(
>      unpackHalf2x16(_276.x).x,
>      unpackHalf2x16(_276.y).x,
>      unpackHalf2x16(_276.z).x,
>      unpackHalf2x16(_276.w).x);
>    r4.x = r3.z;
>    r4.y = r2.z;
>    int _304 = (floatBitsToInt(r1.z) * 8) + (int(16u) / 4);
>    r5 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _304 + 0).x,
>      texelFetch(t2, _304 + 1).x,
>      texelFetch(t2, _304 + 2).x,
>      texelFetch(t2, _304 + 3).x));
>    r0.y = uintBitsToFloat(floatBitsToUint(r5.x) & 65535u);
>    r4.z = unpackHalf2x16(floatBitsToUint(r0.y)).x;
>    int _340 = (floatBitsToInt(r1.w) * 8) + (int(0u) / 4);
>    r6 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _340 + 0).x,
>      texelFetch(t2, _340 + 1).x,
>      texelFetch(t2, _340 + 2).x,
>      texelFetch(t2, _340 + 3).x));
>    int _362 = (floatBitsToInt(r1.w) * 8) + (int(16u) / 4);
>    r7 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _362 + 0).x,
>      texelFetch(t2, _362 + 1).x,
>      texelFetch(t2, _362 + 2).x,
>      texelFetch(t2, _362 + 3).x));
>    r8 = uintBitsToFloat(floatBitsToUint(r6) & uvec4(65535u));
>    r6 = uintBitsToFloat(floatBitsToUint(r6) >> uvec4(16u));
>    uvec4 _387 = floatBitsToUint(r6);
>    r6 = vec4(
>      unpackHalf2x16(_387.x).x,
>      unpackHalf2x16(_387.y).x,
>      unpackHalf2x16(_387.z).x,
>      unpackHalf2x16(_387.w).x);
>    uvec4 _403 = floatBitsToUint(r8.xzyw);
>    r8 = vec4(
>      unpackHalf2x16(_403.x).x,
>      unpackHalf2x16(_403.y).x,
>      unpackHalf2x16(_403.z).x,
>      unpackHalf2x16(_403.w).x);
>    r9.x = r8.z;
>    r9.y = r6.z;
>    r0.y = uintBitsToFloat(floatBitsToUint(r7.x) & 65535u);
>    r9.z = unpackHalf2x16(floatBitsToUint(r0.y)).x;
>    r9.w = r7.w;
>    r0.y = shader_in[3].y + shader_in[3].z;
>    r0.y = uintBitsToFloat(1065353216u) / r0.y;
>    vec2 _464 = r0.yy * shader_in[3].zy;
>    r1 = vec4(r1.x, r1.y, _464.x, _464.y);
>    r9 *= r1.wwww;
>    r4.w = r5.w;
>    r4 = fma(r1.zzzz, r4, r9);
>    r9.xyz = vec3(floatBitsToInt(shader_in[0].xyz));
>    r9.xyz = fma(r9.xyz, cb1.m[1].yyy, cb1.m[1].xxx);
>    r9.w = uintBitsToFloat(1065353216u);
>    r10.z = dot(r9, r4);
>    r11.xz = r3.xw;
>    r11.y = r2.y;
>    r3.xz = r2.xw;
>    r11.w = r5.y;
>    r3.w = r5.z;
>    r2.xz = r8.xw;
>    r2.y = r6.y;
>    r7.xz = r6.xw;
>    r2.w = r7.y;
>    r8.w = r7.z;
>    r5 = r1.wwww * r8;
>    r3 = fma(r1.zzzz, r3, r5);
>    r2 = r1.wwww * r2;
>    r2 = fma(r1.zzzz, r11, r2);
>    r10.x = dot(r9, r2);
>    r10.y = dot(r9, r3);
>    r5.xyz = r10.xyz + (-cb0.m[43].xyz);
>    r0.y = dot(r5.xyz, r5.xyz);
>    r0.y = inversesqrt(r0.y);
>    r5.xyz = r0.yyy * r5.xyz;
>    r5.xyz = fma(r5.xyz, cb0.m[52].zzz, r10.xyz);
>    r6.xy = fma(r5.xy, cb5.m[0].xy, cb5.m[0].zw);
>    r0.y = max(abs(r6.y), abs(r6.x));
>    r0.y = uintBitsToFloat((uintBitsToFloat(1065353216u) >= r0.y) ? 4294967295u : 0u);
>    r6.xy = fma(r5.xy, cb5.m[1].xy, cb5.m[1].zw);
>    r6.zw = floor(r6.yx);
>    r6.xy = fract(r6.xy);
>    r6.zw = uintBitsToFloat(uvec2(r6.zw));
>    r7.xy = vec2(floatBitsToUint(r6.zw));
>    r2.w = fma(r7.x, cb5.m[2].x, r7.y);
>    r2.w = uintBitsToFloat(floatBitsToUint(r0.y) & floatBitsToUint(r2.w));
>    r2.w = intBitsToFloat(int(r2.w));
>    int _709 = (floatBitsToInt(r2.w) * 2) + (int(0u) / 4);
>    r7.xy = uintBitsToFloat(uvec2(
>      texelFetch(t6, _709 + 0).x,
>      texelFetch(t6, _709 + 1).x));
>    r7.zw = uintBitsToFloat(floatBitsToUint(r7.xy) & uvec2(1023u));
>    ivec4 _732 = ivec4(uvec4(10u));
>    ivec4 _735 = ivec4(uvec4(10u, 20u, 10u, 20u));
>    uvec4 _738 = floatBitsToUint(r7.xxyy);
>    r8 = uintBitsToFloat(uvec4(
>      bitfieldExtract(_738.x, _735.x, _732.x),
>      bitfieldExtract(_738.y, _735.y, _732.y),
>      bitfieldExtract(_738.z, _735.z, _732.z),
>      bitfieldExtract(_738.w, _735.w, _732.w)));
>    r7.xy = mix(uintBitsToFloat(uvec2(0u)), uintBitsToFloat(uvec2(1u, 8u)), notEqual(floatBitsToUint(r7.zw), uvec2(0u)));
>    r10 = mix(uintBitsToFloat(uvec4(0u)), uintBitsToFloat(uvec4(2u, 4u, 16u, 32u)), notEqual(floatBitsToUint(r8), uvec4(0u)));
>    r2.w = intBitsToFloat(floatBitsToInt(r7.x) + floatBitsToInt(r10.x));
>    r2.w = intBitsToFloat(floatBitsToInt(r10.y) + floatBitsToInt(r2.w));
>    r2.w = intBitsToFloat(floatBitsToInt(r7.y) + floatBitsToInt(r2.w));
>    r2.w = intBitsToFloat(floatBitsToInt(r10.z) + floatBitsToInt(r2.w));
>    r2.w = intBitsToFloat(floatBitsToInt(r10.w) + floatBitsToInt(r2.w));
>    r0.y = uintBitsToFloat(floatBitsToUint(r0.y) & floatBitsToUint(r2.w));
>    r2.w = uintBitsToFloat(findLSB(floatBitsToUint(r0.y)));
>    r10 = uintBitsToFloat(mix(uvec4(0u), uvec4(4294967295u), equal(floatBitsToInt(r2.wwww), ivec4(uvec4(1u, 2u, 3u, 4u)))));
>    r3.w = (floatBitsToUint(r10.w) != 0u) ? r8.z : r8.w;
>    r3.w = (floatBitsToUint(r10.z) != 0u) ? r7.w : r3.w;
>    r3.w = (floatBitsToUint(r10.y) != 0u) ? r8.y : r3.w;
>    r3.w = (floatBitsToUint(r10.x) != 0u) ? r8.x : r3.w;
>    r3.w = (floatBitsToUint(r2.w) != 0u) ? r3.w : r7.z;
>    r3.w = intBitsToFloat(floatBitsToInt(r3.w) + int(4294967295u));
>    r7.z = float(floatBitsToUint(r3.w));
>    r3.w = intBitsToFloat(floatBitsToInt(r6.w) << int(16u));
>    r3.w = uintBitsToFloat(floatBitsToUint(r6.z) | floatBitsToUint(r3.w));
>    r8.x = uintBitsToFloat(floatBitsToUint(r3.w) >> 16u);
>    r8.y = uintBitsToFloat(floatBitsToUint(r3.w) & 65535u);
>    ivec2 _957 = floatBitsToInt(r2.ww);   /* (0, 0) */
>    ivec2 _958 = ivec2(uvec2(0u));        /* (0, 0) */
>    uvec2 _961 = floatBitsToUint(r8.xy);  /* (70, 103) */
>    r6.zw = uintBitsToFloat(uvec2(
>      bitfieldExtract(_961.x, _958.x, _957.x),
>      bitfieldExtract(_961.y, _958.y, _957.y)));
>    /* r6.zw = (70, 103), but should be (0, 0) */
>    r2.w = intBitsToFloat(int(1u) << int(floatBitsToUint(r2.w)));
>    r2.w = float(floatBitsToUint(r2.w));
>    r2.w = uintBitsToFloat(1065353216u) / r2.w;
>    r6.zw = vec2(floatBitsToUint(r6.zw));
>    r6.xy = r6.zw + r6.xy;
>    r6.xy = r2.ww * r6.xy;
>    r7.xy = fma(cb4.m[5].xy, r6.xy, cb4.m[5].zw);
>    r2.w = textureLod(sampler2DArray(t4, s0), r7.xyz, uintBitsToFloat(0u)).x;
>    r2.w = fma(r2.w, cb4.m[2].x, cb4.m[2].y);
>    r2.w = r2.w + uintBitsToFloat(1008981770u);
>    r2.w = (-r2.w) + r4.w;
>    r3.w = r4.w + cb2.m[3].x;
>    r3.w = (-r3.w) + r5.z;
>    r5.xyz = r5.xyz + (-cb0.m[43].xyz);
>    r3.w = clamp(r3.w * cb2.m[3].y, 0.0, 1.0);
>    r3.w = (-r3.w) + uintBitsToFloat(1065353216u);
>    r3.w = r3.w * r3.w;
>    r0.y = (floatBitsToUint(r0.y) != 0u) ? r3.w : uintBitsToFloat(0u);
>    r3.w = fma(-r0.y, r2.w, r5.z);
>    r4.w = dot(r5.xy, r5.xy);
>    r4.w = sqrt(r4.w);
>    r4.w = r4.w + (-cb0.m[41].x);
>    r6.z = r4.w * cb0.m[41].y;
>    r4.w = uintBitsToFloat((uintBitsToFloat(0u) < r4.w) ? 4294967295u : 0u);
>    r6.w = r6.z * r6.z;
>    r7.w = fma(-r6.z, uintBitsToFloat(1073741824u), uintBitsToFloat(1077936128u));
>    r6.z = uintBitsToFloat((r6.z < uintBitsToFloat(1065353216u)) ? 4294967295u : 0u);
>    r6.w = r6.w * r7.w;
>    r6.w = r6.w * cb0.m[41].z;
>    r6.z = (floatBitsToUint(r6.z) != 0u) ? r6.w : cb0.m[41].z;
>    r4.w = uintBitsToFloat(floatBitsToUint(r4.w) & floatBitsToUint(r6.z));
>    r5.z = r3.w + (-r4.w);
>    o1.z = r3.w;
>    r5.w = uintBitsToFloat(1065353216u);
>    o0.x = dot(r5, cb0.m[20]);
>    o0.y = dot(r5, cb0.m[21]);
>    o0.z = dot(r5, cb0.m[22]);
>    o0.w = dot(r5, cb0.m[23]);
>    o1 = vec3(r5.xy.x, r5.xy.y, o1.z);
>    int _1287 = (floatBitsToInt(r1.y) * 8) + (int(0u) / 4);
>    r5 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _1287 + 0).x,
>      texelFetch(t2, _1287 + 1).x,
>      texelFetch(t2, _1287 + 2).x,
>      texelFetch(t2, _1287 + 3).x));
>    r8 = uintBitsToFloat(floatBitsToUint(r5) & uvec4(65535u));
>    r5 = uintBitsToFloat(floatBitsToUint(r5) >> uvec4(16u));
>    uvec4 _1312 = floatBitsToUint(r5);
>    r5 = vec4(
>      unpackHalf2x16(_1312.x).x,
>      unpackHalf2x16(_1312.y).x,
>      unpackHalf2x16(_1312.z).x,
>      unpackHalf2x16(_1312.w).x);
>    uvec4 _1328 = floatBitsToUint(r8.xzyw);
>    r8 = vec4(
>      unpackHalf2x16(_1328.x).x,
>      unpackHalf2x16(_1328.y).x,
>      unpackHalf2x16(_1328.z).x,
>      unpackHalf2x16(_1328.w).x);
>    r10.x = r8.z;
>    r10.y = r5.z;
>    int _1356 = (floatBitsToInt(r1.y) * 8) + (int(16u) / 4);
>    r11 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _1356 + 0).x,
>      texelFetch(t2, _1356 + 1).x,
>      texelFetch(t2, _1356 + 2).x,
>      texelFetch(t2, _1356 + 3).x));
>    r1.y = uintBitsToFloat(floatBitsToUint(r11.x) & 65535u);
>    r10.z = unpackHalf2x16(floatBitsToUint(r1.y)).x;
>    r10.w = r11.w;
>    r10 = r1.wwww * r10;
>    int _1400 = (floatBitsToInt(r1.x) * 8) + (int(0u) / 4);
>    r12 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _1400 + 0).x,
>      texelFetch(t2, _1400 + 1).x,
>      texelFetch(t2, _1400 + 2).x,
>      texelFetch(t2, _1400 + 3).x));
>    int _1422 = (floatBitsToInt(r1.x) * 8) + (int(16u) / 4);
>    r13 = uintBitsToFloat(uvec4(
>      texelFetch(t2, _1422 + 0).x,
>      texelFetch(t2, _1422 + 1).x,
>      texelFetch(t2, _1422 + 2).x,
>      texelFetch(t2, _1422 + 3).x));
>    r14 = uintBitsToFloat(floatBitsToUint(r12) & uvec4(65535u));
>    r12 = uintBitsToFloat(floatBitsToUint(r12) >> uvec4(16u));
>    uvec4 _1447 = floatBitsToUint(r12);
>    r12 = vec4(
>      unpackHalf2x16(_1447.x).x,
>      unpackHalf2x16(_1447.y).x,
>      unpackHalf2x16(_1447.z).x,
>      unpackHalf2x16(_1447.w).x);
>    uvec4 _1463 = floatBitsToUint(r14.xzyw);
>    r14 = vec4(
>      unpackHalf2x16(_1463.x).x,
>      unpackHalf2x16(_1463.y).x,
>      unpackHalf2x16(_1463.z).x,
>      unpackHalf2x16(_1463.w).x);
>    r15.x = r14.z;
>    r15.y = r12.z;
>    r1.x = uintBitsToFloat(floatBitsToUint(r13.x) & 65535u);
>    r15.z = unpackHalf2x16(floatBitsToUint(r1.x)).x;
>    r15.w = r13.w;
>    r10 = fma(r1.zzzz, r15, r10);
>    r10.z = dot(r9, r10);
>    r15.xz = r14.xw;
>    r15.y = r12.y;
>    r14.xz = r12.xw;
>    r15.w = r13.y;
>    r14.w = r13.z;
>    r12.xz = r8.xw;
>    r12.y = r5.y;
>    r8.xz = r5.xw;
>    r12.w = r11.y;
>    r8.w = r11.z;
>    r5 = r1.wwww * r8;
>    r5 = fma(r1.zzzz, r14, r5);
>    r10.y = dot(r9, r5);
>    r5 = r1.wwww * r12;
>    r1 = fma(r1.zzzz, r15, r5);
>    r10.x = dot(r9, r1);
>    r1.xyz = r10.xyz + (-cb0.m[43].xyz);
>    r1.w = dot(r1.xyz, r1.xyz);
>    r1.w = inversesqrt(r1.w);
>    r1.xyz = r1.www * r1.xyz;
>    r1.xyz = fma(r1.xyz, cb0.m[52].zzz, r10.xyz);
>    r1.xyz = r1.xyz + (-cb0.m[44].xyz);
>    r3.w = dot(r1.xy, r1.xy);
>    r2.w = fma(-r0.y, r2.w, r1.z);
>    r3.w = sqrt(r3.w);
>    r3.w = r3.w + (-cb0.m[41].x);
>    r4.w = r3.w * cb0.m[41].y;
>    r3.w = uintBitsToFloat((uintBitsToFloat(0u) < r3.w) ? 4294967295u : 0u);
>    r5.x = r4.w * r4.w;
>    r5.y = fma(-r4.w, uintBitsToFloat(1073741824u), uintBitsToFloat(1077936128u));
>    r4.w = uintBitsToFloat((r4.w < uintBitsToFloat(1065353216u)) ? 4294967295u : 0u);
>    r5.x = r5.y * r5.x;
>    r5.x = r5.x * cb0.m[41].z;
>    r4.w = (floatBitsToUint(r4.w) != 0u) ? r5.x : cb0.m[41].z;
>    r3.w = uintBitsToFloat(floatBitsToUint(r3.w) & floatBitsToUint(r4.w));
>    r1.z = r2.w + (-r3.w);
>    r1.w = uintBitsToFloat(1065353216u);
>    o2.x = dot(r1, cb0.m[24]);
>    o2.y = dot(r1, cb0.m[25]);
>    o2.z = dot(r1, cb0.m[27]);
>    r1.xy = vec2(floatBitsToInt(shader_in[1].xy));
>    o3.xy = fma(r1.xy, cb1.m[1].ww, cb1.m[1].zz);
>    r1.xy = vec2(floatBitsToInt(shader_in[2].xy));
>    o3.zw = fma(r1.xy, cb1.m[1].ww, cb1.m[1].zz);
>    r1 = mix(cb4.m[3], cb4.m[4], notEqual(floatBitsToUint(cb5.m[2].yyyy), uvec4(0u)));
>    r7.xy = fma(r1.xy, r6.xy, r1.zw);
>    r1.xyz = textureLod(sampler2DArray(t5, s1), r7.xyzx.xyz, uintBitsToFloat(0u)).xyw;
>    r1.xy = mix(r1.zy, r1.xy, notEqual(floatBitsToUint(cb5.m[2].yy), uvec2(0u)));
>    r1.xy = fma(r1.xy, uintBitsToFloat(uvec2(1073774850u)), uintBitsToFloat(uvec2(3212836864u)));
>    r1.w = dot(r1.xy, r1.xy);
>    r1.w = min(r1.w, uintBitsToFloat(1065353216u));
>    r1.w = fma(-r1.w, uintBitsToFloat(1065351538u), uintBitsToFloat(1065353216u));
>    r1.z = sqrt(r1.w);
>    r1.w = dot(r1.xyz, r1.xyz);
>    r1.w = inversesqrt(r1.w);
>    r5.xyz = fma(shader_in[5].xyz, uintBitsToFloat(uvec3(1073741824u)), uintBitsToFloat(uvec3(3212836864u)));
>    r1.xyz = fma(r1.xyz, r1.www, -r5.xyz);
>    r1.w = abs(r5.z) * abs(r5.z);
>    r1.w = r1.w * r1.w;
>    r1.w = r1.w * r1.w;
>    r0.y = r0.y * r1.w;
>    r1.xyz = fma(r0.yyy, r1.xyz, r5.xyz);
>    r0.y = dot(r1.xyz, r1.xyz);
>    r0.y = inversesqrt(r0.y);
>    r1.xyz = r0.yyy * r1.xyz;
>    r2.x = dot(r1.xyz, r2.xyz);
>    r2.y = dot(r1.xyz, r3.xyz);
>    r2.z = dot(r1.xyz, r4.xyz);
>    r0.y = dot(r2.xyz, r2.xyz);
>    r0.y = inversesqrt(r0.y);
>    o4 = r0.yyy * r2.xyz;
>    r0.y = uintBitsToFloat(texelFetch(t3, ((floatBitsToInt(r0.x) * 36) + (int(120u) / 4)) + 0).x);
>    r1.xy = intBitsToFloat(floatBitsToInt(r0.yy) + ivec2(uvec2(160u, 224u)));
>    r2.yz = intBitsToFloat(floatBitsToInt(r0.zx) << ivec2(uvec2(2u, 16u)));
>    r0.x = intBitsToFloat(floatBitsToInt(r1.x) + floatBitsToInt(r2.y));
>    r0.x = uintBitsToFloat(texelFetch(t0, (floatBitsToInt(r0.x) / 4) + 0).x);
>    r0.x = intBitsToFloat(floatBitsToInt(r0.w) + floatBitsToInt(r0.x));
>    r0.x = intBitsToFloat((floatBitsToInt(r0.x) * int(48u)) + floatBitsToInt(r1.y));
>    r0.x = intBitsToFloat(floatBitsToInt(r0.x) + int(36u));
>    r2.x = uintBitsToFloat(texelFetch(t0, (floatBitsToInt(r0.x) / 4) + 0).x);
>    r2.w = shader_in[7].x;
>    o5 = r2.wxz;
>}
>
>void main() {
>    shader_in[0] = intBitsToFloat(v0);
>    shader_in[1].xy = intBitsToFloat(v1);
>    shader_in[2].xy = intBitsToFloat(v2);
>    shader_in[3] = v3;
>    shader_in[4] = uintBitsToFloat(v4);
>    shader_in[5] = v5;
>    shader_in[7].x = uintBitsToFloat(gl_InstanceIndex);
>    vs_main();
>    gl_Position = o0;
>}
>

Actions: View

Attachments on bug 107276: 140691 | 140692 | 140693 | 140694 | 140695

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.