2022-09-24 03:14:49 +00:00
|
|
|
---
|
|
|
|
source: render/naga-agal/tests/wgsl.rs
|
|
|
|
expression: output
|
|
|
|
---
|
|
|
|
struct FragmentOutput {
|
|
|
|
@location(0) member: vec4<f32>,
|
|
|
|
}
|
|
|
|
|
|
|
|
@group(0) @binding(1)
|
2023-07-29 18:50:27 +00:00
|
|
|
var<uniform> constant_registers: array<vec4<f32>, 28>;
|
2022-09-24 03:14:49 +00:00
|
|
|
@group(0) @binding(2)
|
|
|
|
var sampler0_: sampler;
|
|
|
|
@group(0) @binding(3)
|
|
|
|
var sampler1_: sampler;
|
|
|
|
@group(0) @binding(4)
|
|
|
|
var sampler2_: sampler;
|
|
|
|
@group(0) @binding(5)
|
|
|
|
var sampler3_: sampler;
|
|
|
|
@group(0) @binding(6)
|
2023-03-14 02:25:53 +00:00
|
|
|
var sampler4_: sampler;
|
|
|
|
@group(0) @binding(7)
|
|
|
|
var sampler5_: sampler;
|
|
|
|
@group(0) @binding(8)
|
|
|
|
var sampler6_: sampler;
|
|
|
|
@group(0) @binding(9)
|
|
|
|
var sampler7_: sampler;
|
|
|
|
@group(0) @binding(10)
|
2022-09-24 03:14:49 +00:00
|
|
|
var texture0_: texture_cube<f32>;
|
|
|
|
|
|
|
|
@fragment
|
|
|
|
fn main(@location(0) param: vec4<f32>) -> FragmentOutput {
|
|
|
|
var dest_temp: vec4<f32>;
|
|
|
|
var temporary0_: vec4<f32>;
|
|
|
|
var temporary1_: vec4<f32>;
|
|
|
|
var temporary2_: vec4<f32>;
|
|
|
|
var temporary4_: vec4<f32>;
|
|
|
|
var temporary3_: vec4<f32>;
|
|
|
|
var temporary5_: vec4<f32>;
|
|
|
|
var temporary6_: vec4<f32>;
|
|
|
|
var temporary7_: vec4<f32>;
|
|
|
|
var temporary8_: vec4<f32>;
|
|
|
|
var temporary10_: vec4<f32>;
|
|
|
|
var temporary9_: vec4<f32>;
|
|
|
|
var temporary11_: vec4<f32>;
|
|
|
|
var temporary12_: vec4<f32>;
|
|
|
|
var temporary13_: vec4<f32>;
|
|
|
|
var temporary14_: vec4<f32>;
|
|
|
|
var temporary15_: vec4<f32>;
|
|
|
|
var temporary16_: vec4<f32>;
|
|
|
|
var temporary20_: vec4<f32>;
|
|
|
|
var temporary18_: vec4<f32>;
|
|
|
|
var temporary17_: vec4<f32>;
|
|
|
|
var temporary19_: vec4<f32>;
|
|
|
|
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e12: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary0_ = _e12.xxxy;
|
|
|
|
let _e19: vec4<f32> = constant_registers[3u];
|
|
|
|
temporary1_.x = (param.xxxx * _e19.xxxx).x;
|
2022-09-24 03:14:49 +00:00
|
|
|
temporary1_.y = param.yyyy.x;
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e30: vec4<f32> = constant_registers[1u];
|
|
|
|
let _e31: vec4<f32> = _e30.xxxx;
|
|
|
|
temporary1_.z = _e31.z;
|
|
|
|
temporary1_.w = _e31.w;
|
|
|
|
let _e36: vec4<f32> = temporary1_;
|
|
|
|
let _e40: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e42: vec4<f32> = (_e36.zzzw * _e40.zzzz);
|
|
|
|
temporary1_.z = _e42.z;
|
|
|
|
temporary1_.w = _e42.w;
|
|
|
|
let _e47: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.z = cos(_e47.zzzz).x;
|
|
|
|
let _e52: vec4<f32> = temporary1_;
|
|
|
|
let _e56: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary2_.x = (_e52.zzzz * _e56.wwww).x;
|
|
|
|
let _e64: vec4<f32> = constant_registers[1u];
|
|
|
|
temporary1_.z = _e64.yyyy.x;
|
|
|
|
let _e68: vec4<f32> = temporary1_;
|
|
|
|
let _e72: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = (_e68.zzzz + _e72.yyyy).x;
|
|
|
|
let _e77: vec4<f32> = temporary1_;
|
|
|
|
let _e81: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary1_.z = (_e77.zzzz * _e81.xxxx).x;
|
|
|
|
let _e86: vec4<f32> = temporary1_;
|
|
|
|
let _e90: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary1_.z = max(_e86.zzzz, _e90.yyyy).x;
|
|
|
|
let _e95: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.w = sin(_e95.wwww).x;
|
|
|
|
let _e100: vec4<f32> = temporary1_;
|
|
|
|
let _e104: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary2_.z = (_e100.wwww * _e104.wwww).x;
|
|
|
|
let _e109: vec4<f32> = temporary1_;
|
|
|
|
temporary2_.y = _e109.zzzz.x;
|
|
|
|
let _e115: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e116: vec4<f32> = _e115.xxxx;
|
|
|
|
temporary4_.x = _e116.x;
|
|
|
|
temporary4_.z = _e116.z;
|
|
|
|
let _e124: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary4_.y = _e124.zzzz.x;
|
|
|
|
let _e130: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.w = _e130.yyyy.x;
|
|
|
|
let _e134: vec4<f32> = temporary4_;
|
|
|
|
let _e136: vec4<f32> = temporary2_;
|
|
|
|
let _e138: vec4<f32> = (_e134.xyzz - _e136.xyzz);
|
|
|
|
temporary3_.x = _e138.x;
|
|
|
|
temporary3_.y = _e138.y;
|
|
|
|
temporary3_.z = _e138.z;
|
|
|
|
let _e146: vec4<f32> = temporary3_;
|
|
|
|
let _e148: vec3<f32> = normalize(_e146.xyz);
|
|
|
|
temporary3_.x = _e148.x;
|
|
|
|
temporary3_.y = _e148.y;
|
|
|
|
temporary3_.z = _e148.z;
|
|
|
|
let _e157: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e159: vec4<f32> = temporary3_;
|
|
|
|
let _e161: vec3<f32> = cross(_e157.xyx, _e159.xyz);
|
|
|
|
let _e166: vec4<f32> = vec4<f32>(_e161.x, _e161.y, _e161.z, 1.0);
|
|
|
|
temporary5_.x = _e166.x;
|
|
|
|
temporary5_.y = _e166.y;
|
|
|
|
temporary5_.z = _e166.z;
|
|
|
|
let _e174: vec4<f32> = temporary5_;
|
|
|
|
let _e176: vec3<f32> = normalize(_e174.xyz);
|
|
|
|
temporary6_.x = _e176.x;
|
|
|
|
temporary6_.y = _e176.y;
|
|
|
|
temporary6_.z = _e176.z;
|
|
|
|
let _e184: vec4<f32> = temporary3_;
|
|
|
|
let _e186: vec4<f32> = temporary6_;
|
|
|
|
let _e188: vec3<f32> = cross(_e184.xyz, _e186.xyz);
|
|
|
|
let _e193: vec4<f32> = vec4<f32>(_e188.x, _e188.y, _e188.z, 1.0);
|
|
|
|
temporary5_.x = _e193.x;
|
|
|
|
temporary5_.y = _e193.y;
|
|
|
|
temporary5_.z = _e193.z;
|
|
|
|
let _e200: vec4<f32> = temporary3_;
|
|
|
|
let _e202: vec4<f32> = temporary1_;
|
|
|
|
let _e204: vec4<f32> = (_e200.xyzz * _e202.wwww);
|
|
|
|
temporary3_.x = _e204.x;
|
|
|
|
temporary3_.y = _e204.y;
|
|
|
|
temporary3_.z = _e204.z;
|
|
|
|
let _e211: vec4<f32> = temporary6_;
|
|
|
|
let _e213: vec4<f32> = temporary1_;
|
|
|
|
let _e215: vec4<f32> = (_e211.xyzz * _e213.xxxx);
|
|
|
|
temporary6_.x = _e215.x;
|
|
|
|
temporary6_.y = _e215.y;
|
|
|
|
temporary6_.z = _e215.z;
|
|
|
|
let _e222: vec4<f32> = temporary3_;
|
|
|
|
let _e224: vec4<f32> = temporary6_;
|
|
|
|
let _e226: vec4<f32> = (_e222.xyzz + _e224.xyzz);
|
|
|
|
temporary7_.x = _e226.x;
|
|
|
|
temporary7_.y = _e226.y;
|
|
|
|
temporary7_.z = _e226.z;
|
|
|
|
let _e234: vec4<f32> = temporary5_;
|
|
|
|
let _e236: vec4<f32> = temporary1_;
|
|
|
|
let _e238: vec4<f32> = (_e234.xyzz * _e236.yyyy);
|
|
|
|
temporary5_.x = _e238.x;
|
|
|
|
temporary5_.y = _e238.y;
|
|
|
|
temporary5_.z = _e238.z;
|
|
|
|
let _e245: vec4<f32> = temporary7_;
|
|
|
|
let _e247: vec4<f32> = temporary5_;
|
|
|
|
let _e249: vec4<f32> = (_e245.xyzz + _e247.xyzz);
|
|
|
|
temporary5_.x = _e249.x;
|
|
|
|
temporary5_.y = _e249.y;
|
|
|
|
temporary5_.z = _e249.z;
|
|
|
|
let _e256: vec4<f32> = temporary5_;
|
|
|
|
let _e258: vec3<f32> = normalize(_e256.xyz);
|
|
|
|
temporary8_.x = _e258.x;
|
|
|
|
temporary8_.y = _e258.y;
|
|
|
|
temporary8_.z = _e258.z;
|
|
|
|
let _e266: vec4<f32> = temporary8_;
|
|
|
|
let _e267: vec4<f32> = _e266.xyzz;
|
|
|
|
temporary10_.x = _e267.x;
|
|
|
|
temporary10_.y = _e267.y;
|
|
|
|
temporary10_.z = _e267.z;
|
|
|
|
let _e275: vec4<f32> = temporary10_;
|
|
|
|
let _e276: vec4<f32> = _e275.xyzz;
|
|
|
|
temporary9_.x = _e276.x;
|
|
|
|
temporary9_.y = _e276.y;
|
|
|
|
temporary9_.z = _e276.z;
|
|
|
|
let _e286: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e287: vec4<f32> = _e286.yxxx;
|
|
|
|
temporary11_.x = _e287.x;
|
|
|
|
temporary11_.y = _e287.y;
|
|
|
|
temporary11_.z = _e287.z;
|
|
|
|
let _e295: vec4<f32> = temporary11_;
|
|
|
|
let _e299: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e295.xxxx != _e299.xxxx)) {
|
|
|
|
let _e305: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = _e305.xxxx.x;
|
|
|
|
let _e311: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary4_.z = _e311.wwww.x;
|
|
|
|
let _e317: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e318: vec4<f32> = _e317.xyxx;
|
|
|
|
temporary3_.x = _e318.x;
|
|
|
|
temporary3_.y = _e318.y;
|
|
|
|
temporary3_.z = _e318.z;
|
|
|
|
let _e325: vec4<f32> = temporary3_;
|
|
|
|
let _e326: vec4<f32> = _e325.xyzz;
|
|
|
|
temporary12_.x = _e326.x;
|
|
|
|
temporary12_.y = _e326.y;
|
|
|
|
temporary12_.z = _e326.z;
|
|
|
|
let _e336: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary1_.x = _e336.wwww.x;
|
|
|
|
let _e340: vec4<f32> = temporary2_;
|
|
|
|
let _e344: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e346: vec4<f32> = (_e340.xyzz - _e344.xxxx);
|
|
|
|
temporary13_.x = _e346.x;
|
|
|
|
temporary13_.y = _e346.y;
|
|
|
|
temporary13_.z = _e346.z;
|
|
|
|
let _e354: vec4<f32> = temporary13_;
|
|
|
|
let _e356: vec4<f32> = temporary12_;
|
|
|
|
temporary1_.y = dot(_e354.xyz, _e356.xyz);
|
|
|
|
let _e360: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.y = -(_e360.yyyy).x;
|
|
|
|
let _e365: vec4<f32> = temporary9_;
|
|
|
|
let _e367: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.x = dot(_e365.xyz, _e367.xyz);
|
|
|
|
let _e371: vec4<f32> = temporary1_;
|
|
|
|
let _e373: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e371.yyyy / _e373.xxxx).x;
|
|
|
|
let _e378: vec4<f32> = temporary12_;
|
|
|
|
temporary1_.y = _e378.yyyy.x;
|
|
|
|
let _e384: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e386: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.w = vec4<f32>((_e384.xxxx < _e386.yyyy)).x;
|
|
|
|
let _e392: vec4<f32> = temporary1_;
|
|
|
|
let _e396: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e392.wwww != _e396.xxxx)) {
|
|
|
|
let _e400: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.x = _e400.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e404: vec4<f32> = temporary1_;
|
|
|
|
temporary4_.y = _e404.xxxx.x;
|
|
|
|
let _e408: vec4<f32> = temporary4_;
|
|
|
|
let _e410: vec4<f32> = temporary4_;
|
|
|
|
temporary1_.x = vec4<f32>((_e408.yyyy < _e410.zzzz)).x;
|
|
|
|
let _e416: vec4<f32> = temporary1_;
|
|
|
|
let _e420: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e416.xxxx != _e420.xxxx)) {
|
|
|
|
let _e424: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e424.yyyy.x;
|
|
|
|
let _e428: vec4<f32> = temporary3_;
|
|
|
|
let _e429: vec4<f32> = _e428.xyzz;
|
|
|
|
temporary6_.x = _e429.x;
|
|
|
|
temporary6_.y = _e429.y;
|
|
|
|
temporary6_.z = _e429.z;
|
|
|
|
let _e438: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = _e438.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e442: vec4<f32> = temporary2_;
|
|
|
|
let _e443: vec4<f32> = _e442.xyzz;
|
|
|
|
temporary5_.x = _e443.x;
|
|
|
|
temporary5_.y = _e443.y;
|
|
|
|
temporary5_.z = _e443.z;
|
|
|
|
let _e450: vec4<f32> = temporary9_;
|
|
|
|
let _e451: vec4<f32> = _e450.xyzz;
|
|
|
|
temporary10_.x = _e451.x;
|
|
|
|
temporary10_.y = _e451.y;
|
|
|
|
temporary10_.z = _e451.z;
|
|
|
|
let _e460: vec4<f32> = constant_registers[4u];
|
|
|
|
let _e461: vec4<f32> = _e460.xyzz;
|
|
|
|
temporary8_.x = _e461.x;
|
|
|
|
temporary8_.y = _e461.y;
|
|
|
|
temporary8_.z = _e461.z;
|
|
|
|
let _e470: vec4<f32> = constant_registers[6u];
|
|
|
|
temporary14_.x = _e470.xxxx.x;
|
|
|
|
let _e475: vec4<f32> = temporary3_;
|
|
|
|
let _e476: vec4<f32> = _e475.xyzz;
|
|
|
|
temporary15_.x = _e476.x;
|
|
|
|
temporary15_.y = _e476.y;
|
|
|
|
temporary15_.z = _e476.z;
|
|
|
|
let _e486: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary1_.x = _e486.wwww.x;
|
|
|
|
let _e490: vec4<f32> = temporary5_;
|
|
|
|
let _e492: vec4<f32> = temporary8_;
|
|
|
|
let _e494: vec4<f32> = (_e490.xyzz - _e492.xyzz);
|
|
|
|
temporary16_.x = _e494.x;
|
|
|
|
temporary16_.y = _e494.y;
|
|
|
|
temporary16_.z = _e494.z;
|
|
|
|
let _e502: vec4<f32> = temporary16_;
|
|
|
|
let _e504: vec4<f32> = temporary10_;
|
|
|
|
temporary14_.z = dot(_e502.xyz, _e504.xyz);
|
|
|
|
let _e508: vec4<f32> = temporary14_;
|
|
|
|
let _e510: vec4<f32> = temporary14_;
|
|
|
|
let _e512: vec4<f32> = (_e508.zzzx * _e510.zzzx);
|
|
|
|
temporary4_.x = _e512.x;
|
|
|
|
temporary4_.w = _e512.w;
|
|
|
|
let _e517: vec4<f32> = temporary16_;
|
|
|
|
let _e519: vec4<f32> = temporary16_;
|
|
|
|
temporary1_.y = dot(_e517.xyz, _e519.xyz);
|
|
|
|
let _e523: vec4<f32> = temporary4_;
|
|
|
|
let _e525: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.w = (_e523.xxxx - _e525.yyyy).x;
|
|
|
|
let _e530: vec4<f32> = temporary1_;
|
|
|
|
let _e532: vec4<f32> = temporary4_;
|
|
|
|
temporary13_.x = (_e530.wwww + _e532.wwww).x;
|
|
|
|
let _e537: vec4<f32> = temporary13_;
|
|
|
|
temporary1_.w = _e537.xxxx.x;
|
|
|
|
let _e543: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e545: vec4<f32> = temporary1_;
|
|
|
|
temporary2_.w = vec4<f32>((_e543.xxxx < _e545.wwww)).x;
|
|
|
|
let _e551: vec4<f32> = temporary2_;
|
|
|
|
let _e555: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e551.wwww != _e555.xxxx)) {
|
|
|
|
let _e559: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.w = sqrt(_e559.wwww).x;
|
|
|
|
let _e564: vec4<f32> = temporary14_;
|
|
|
|
temporary1_.y = -(_e564.zzzz).x;
|
|
|
|
let _e569: vec4<f32> = temporary1_;
|
|
|
|
let _e571: vec4<f32> = temporary1_;
|
|
|
|
temporary2_.w = (_e569.yyyy - _e571.wwww).x;
|
|
|
|
let _e578: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e580: vec4<f32> = temporary2_;
|
|
|
|
temporary1_.y = vec4<f32>((_e578.xxxx < _e580.wwww)).x;
|
|
|
|
let _e586: vec4<f32> = temporary1_;
|
|
|
|
let _e590: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e586.yyyy != _e590.xxxx)) {
|
|
|
|
let _e594: vec4<f32> = temporary2_;
|
|
|
|
temporary1_.x = _e594.wwww.x;
|
|
|
|
let _e598: vec4<f32> = temporary10_;
|
|
|
|
let _e600: vec4<f32> = temporary2_;
|
|
|
|
let _e602: vec4<f32> = (_e598.xyzz * _e600.wwww);
|
|
|
|
temporary13_.x = _e602.x;
|
|
|
|
temporary13_.y = _e602.y;
|
|
|
|
temporary13_.z = _e602.z;
|
|
|
|
let _e609: vec4<f32> = temporary5_;
|
|
|
|
let _e611: vec4<f32> = temporary13_;
|
|
|
|
let _e613: vec4<f32> = (_e609.xyzz + _e611.xyzz);
|
|
|
|
temporary12_.x = _e613.x;
|
|
|
|
temporary12_.y = _e613.y;
|
|
|
|
temporary12_.z = _e613.z;
|
|
|
|
let _e620: vec4<f32> = temporary12_;
|
|
|
|
let _e622: vec4<f32> = temporary8_;
|
|
|
|
let _e624: vec4<f32> = (_e620.xyzz - _e622.xyzz);
|
|
|
|
temporary14_.x = _e624.x;
|
|
|
|
temporary14_.y = _e624.y;
|
|
|
|
temporary14_.z = _e624.z;
|
|
|
|
let _e631: vec4<f32> = temporary14_;
|
|
|
|
let _e633: vec3<f32> = normalize(_e631.xyz);
|
|
|
|
temporary16_.x = _e633.x;
|
|
|
|
temporary16_.y = _e633.y;
|
|
|
|
temporary16_.z = _e633.z;
|
|
|
|
let _e640: vec4<f32> = temporary16_;
|
|
|
|
let _e641: vec4<f32> = _e640.xyzz;
|
|
|
|
temporary20_.x = _e641.x;
|
|
|
|
temporary20_.y = _e641.y;
|
|
|
|
temporary20_.z = _e641.z;
|
|
|
|
let _e649: vec4<f32> = temporary20_;
|
|
|
|
let _e650: vec4<f32> = _e649.xyzz;
|
|
|
|
temporary15_.x = _e650.x;
|
|
|
|
temporary15_.y = _e650.y;
|
|
|
|
temporary15_.z = _e650.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e657: vec4<f32> = temporary1_;
|
|
|
|
temporary4_.y = _e657.xxxx.x;
|
|
|
|
let _e661: vec4<f32> = temporary15_;
|
|
|
|
let _e662: vec4<f32> = _e661.xyzz;
|
|
|
|
temporary3_.x = _e662.x;
|
|
|
|
temporary3_.y = _e662.y;
|
|
|
|
temporary3_.z = _e662.z;
|
|
|
|
let _e669: vec4<f32> = temporary4_;
|
|
|
|
let _e671: vec4<f32> = temporary4_;
|
|
|
|
temporary1_.x = vec4<f32>((_e669.yyyy < _e671.zzzz)).x;
|
|
|
|
let _e677: vec4<f32> = temporary1_;
|
|
|
|
let _e681: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e677.xxxx != _e681.xxxx)) {
|
|
|
|
let _e685: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e685.yyyy.x;
|
|
|
|
let _e689: vec4<f32> = temporary3_;
|
|
|
|
let _e690: vec4<f32> = _e689.xyzz;
|
|
|
|
temporary6_.x = _e690.x;
|
|
|
|
temporary6_.y = _e690.y;
|
|
|
|
temporary6_.z = _e690.z;
|
|
|
|
let _e699: vec4<f32> = constant_registers[5u];
|
|
|
|
let _e700: vec4<f32> = _e699.xyzz;
|
|
|
|
temporary7_.x = _e700.x;
|
|
|
|
temporary7_.y = _e700.y;
|
|
|
|
temporary7_.z = _e700.z;
|
|
|
|
let _e709: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e709.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e713: vec4<f32> = temporary2_;
|
|
|
|
let _e714: vec4<f32> = _e713.xyzz;
|
|
|
|
temporary5_.x = _e714.x;
|
|
|
|
temporary5_.y = _e714.y;
|
|
|
|
temporary5_.z = _e714.z;
|
|
|
|
let _e721: vec4<f32> = temporary9_;
|
|
|
|
let _e722: vec4<f32> = _e721.xyzz;
|
|
|
|
temporary10_.x = _e722.x;
|
|
|
|
temporary10_.y = _e722.y;
|
|
|
|
temporary10_.z = _e722.z;
|
|
|
|
let _e731: vec4<f32> = constant_registers[7u];
|
|
|
|
let _e732: vec4<f32> = _e731.xyzz;
|
|
|
|
temporary8_.x = _e732.x;
|
|
|
|
temporary8_.y = _e732.y;
|
|
|
|
temporary8_.z = _e732.z;
|
|
|
|
let _e741: vec4<f32> = constant_registers[9u];
|
|
|
|
temporary15_.x = _e741.xxxx.x;
|
|
|
|
let _e745: vec4<f32> = temporary3_;
|
|
|
|
let _e746: vec4<f32> = _e745.xyzz;
|
|
|
|
temporary18_.x = _e746.x;
|
|
|
|
temporary18_.y = _e746.y;
|
|
|
|
temporary18_.z = _e746.z;
|
|
|
|
let _e756: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary1_.x = _e756.wwww.x;
|
|
|
|
let _e760: vec4<f32> = temporary5_;
|
|
|
|
let _e762: vec4<f32> = temporary8_;
|
|
|
|
let _e764: vec4<f32> = (_e760.xyzz - _e762.xyzz);
|
|
|
|
temporary17_.x = _e764.x;
|
|
|
|
temporary17_.y = _e764.y;
|
|
|
|
temporary17_.z = _e764.z;
|
|
|
|
let _e772: vec4<f32> = temporary17_;
|
|
|
|
let _e774: vec4<f32> = temporary10_;
|
|
|
|
temporary15_.z = dot(_e772.xyz, _e774.xyz);
|
|
|
|
let _e778: vec4<f32> = temporary15_;
|
|
|
|
let _e780: vec4<f32> = temporary15_;
|
|
|
|
let _e782: vec4<f32> = (_e778.zzzx * _e780.zzzx);
|
|
|
|
temporary4_.x = _e782.x;
|
|
|
|
temporary4_.w = _e782.w;
|
|
|
|
let _e787: vec4<f32> = temporary17_;
|
|
|
|
let _e789: vec4<f32> = temporary17_;
|
|
|
|
temporary1_.y = dot(_e787.xyz, _e789.xyz);
|
|
|
|
let _e793: vec4<f32> = temporary4_;
|
|
|
|
let _e795: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.w = (_e793.xxxx - _e795.yyyy).x;
|
|
|
|
let _e800: vec4<f32> = temporary1_;
|
|
|
|
let _e802: vec4<f32> = temporary4_;
|
|
|
|
temporary13_.x = (_e800.wwww + _e802.wwww).x;
|
|
|
|
let _e807: vec4<f32> = temporary13_;
|
|
|
|
temporary1_.w = _e807.xxxx.x;
|
|
|
|
let _e813: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e815: vec4<f32> = temporary1_;
|
|
|
|
temporary2_.w = vec4<f32>((_e813.xxxx < _e815.wwww)).x;
|
|
|
|
let _e821: vec4<f32> = temporary2_;
|
|
|
|
let _e825: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e821.wwww != _e825.xxxx)) {
|
|
|
|
let _e829: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.w = sqrt(_e829.wwww).x;
|
|
|
|
let _e834: vec4<f32> = temporary15_;
|
|
|
|
temporary1_.y = -(_e834.zzzz).x;
|
|
|
|
let _e839: vec4<f32> = temporary1_;
|
|
|
|
let _e841: vec4<f32> = temporary1_;
|
|
|
|
temporary2_.w = (_e839.yyyy - _e841.wwww).x;
|
|
|
|
let _e848: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e850: vec4<f32> = temporary2_;
|
|
|
|
temporary1_.y = vec4<f32>((_e848.xxxx < _e850.wwww)).x;
|
|
|
|
let _e856: vec4<f32> = temporary1_;
|
|
|
|
let _e860: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e856.yyyy != _e860.xxxx)) {
|
|
|
|
let _e864: vec4<f32> = temporary2_;
|
|
|
|
temporary1_.x = _e864.wwww.x;
|
|
|
|
let _e868: vec4<f32> = temporary10_;
|
|
|
|
let _e870: vec4<f32> = temporary2_;
|
|
|
|
let _e872: vec4<f32> = (_e868.xyzz * _e870.wwww);
|
|
|
|
temporary13_.x = _e872.x;
|
|
|
|
temporary13_.y = _e872.y;
|
|
|
|
temporary13_.z = _e872.z;
|
|
|
|
let _e879: vec4<f32> = temporary5_;
|
|
|
|
let _e881: vec4<f32> = temporary13_;
|
|
|
|
let _e883: vec4<f32> = (_e879.xyzz + _e881.xyzz);
|
|
|
|
temporary12_.x = _e883.x;
|
|
|
|
temporary12_.y = _e883.y;
|
|
|
|
temporary12_.z = _e883.z;
|
|
|
|
let _e890: vec4<f32> = temporary12_;
|
|
|
|
let _e892: vec4<f32> = temporary8_;
|
|
|
|
let _e894: vec4<f32> = (_e890.xyzz - _e892.xyzz);
|
|
|
|
temporary14_.x = _e894.x;
|
|
|
|
temporary14_.y = _e894.y;
|
|
|
|
temporary14_.z = _e894.z;
|
|
|
|
let _e901: vec4<f32> = temporary14_;
|
|
|
|
let _e903: vec3<f32> = normalize(_e901.xyz);
|
|
|
|
temporary16_.x = _e903.x;
|
|
|
|
temporary16_.y = _e903.y;
|
|
|
|
temporary16_.z = _e903.z;
|
|
|
|
let _e910: vec4<f32> = temporary16_;
|
|
|
|
let _e911: vec4<f32> = _e910.xyzz;
|
|
|
|
temporary20_.x = _e911.x;
|
|
|
|
temporary20_.y = _e911.y;
|
|
|
|
temporary20_.z = _e911.z;
|
|
|
|
let _e918: vec4<f32> = temporary20_;
|
|
|
|
let _e919: vec4<f32> = _e918.xyzz;
|
|
|
|
temporary18_.x = _e919.x;
|
|
|
|
temporary18_.y = _e919.y;
|
|
|
|
temporary18_.z = _e919.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e926: vec4<f32> = temporary1_;
|
|
|
|
temporary4_.y = _e926.xxxx.x;
|
|
|
|
let _e930: vec4<f32> = temporary18_;
|
|
|
|
let _e931: vec4<f32> = _e930.xyzz;
|
|
|
|
temporary3_.x = _e931.x;
|
|
|
|
temporary3_.y = _e931.y;
|
|
|
|
temporary3_.z = _e931.z;
|
|
|
|
let _e938: vec4<f32> = temporary4_;
|
|
|
|
let _e940: vec4<f32> = temporary4_;
|
|
|
|
temporary1_.x = vec4<f32>((_e938.yyyy < _e940.zzzz)).x;
|
|
|
|
let _e946: vec4<f32> = temporary1_;
|
|
|
|
let _e950: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e946.xxxx != _e950.xxxx)) {
|
|
|
|
let _e954: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e954.yyyy.x;
|
|
|
|
let _e958: vec4<f32> = temporary3_;
|
|
|
|
let _e959: vec4<f32> = _e958.xyzz;
|
|
|
|
temporary6_.x = _e959.x;
|
|
|
|
temporary6_.y = _e959.y;
|
|
|
|
temporary6_.z = _e959.z;
|
|
|
|
let _e968: vec4<f32> = constant_registers[8u];
|
|
|
|
let _e969: vec4<f32> = _e968.xyzz;
|
|
|
|
temporary7_.x = _e969.x;
|
|
|
|
temporary7_.y = _e969.y;
|
|
|
|
temporary7_.z = _e969.z;
|
|
|
|
let _e978: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e978.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e982: vec4<f32> = temporary2_;
|
|
|
|
let _e983: vec4<f32> = _e982.xyzz;
|
|
|
|
temporary5_.x = _e983.x;
|
|
|
|
temporary5_.y = _e983.y;
|
|
|
|
temporary5_.z = _e983.z;
|
|
|
|
let _e990: vec4<f32> = temporary9_;
|
|
|
|
let _e991: vec4<f32> = _e990.xyzz;
|
|
|
|
temporary10_.x = _e991.x;
|
|
|
|
temporary10_.y = _e991.y;
|
|
|
|
temporary10_.z = _e991.z;
|
|
|
|
let _e1000: vec4<f32> = constant_registers[10u];
|
|
|
|
let _e1001: vec4<f32> = _e1000.xyzz;
|
|
|
|
temporary8_.x = _e1001.x;
|
|
|
|
temporary8_.y = _e1001.y;
|
|
|
|
temporary8_.z = _e1001.z;
|
|
|
|
let _e1010: vec4<f32> = constant_registers[12u];
|
|
|
|
temporary15_.x = _e1010.xxxx.x;
|
|
|
|
let _e1014: vec4<f32> = temporary3_;
|
|
|
|
let _e1015: vec4<f32> = _e1014.xyzz;
|
|
|
|
temporary17_.x = _e1015.x;
|
|
|
|
temporary17_.y = _e1015.y;
|
|
|
|
temporary17_.z = _e1015.z;
|
|
|
|
let _e1024: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary15_.y = _e1024.wwww.x;
|
|
|
|
let _e1028: vec4<f32> = temporary5_;
|
|
|
|
let _e1030: vec4<f32> = temporary8_;
|
|
|
|
let _e1032: vec4<f32> = (_e1028.xyzz - _e1030.xyzz);
|
|
|
|
temporary18_.x = _e1032.x;
|
|
|
|
temporary18_.y = _e1032.y;
|
|
|
|
temporary18_.z = _e1032.z;
|
|
|
|
let _e1039: vec4<f32> = temporary18_;
|
|
|
|
let _e1041: vec4<f32> = temporary10_;
|
|
|
|
temporary15_.z = dot(_e1039.xyz, _e1041.xyz);
|
|
|
|
let _e1045: vec4<f32> = temporary15_;
|
|
|
|
let _e1047: vec4<f32> = temporary15_;
|
|
|
|
let _e1049: vec4<f32> = (_e1045.zzzx * _e1047.zzzx);
|
|
|
|
temporary1_.x = _e1049.x;
|
|
|
|
temporary1_.w = _e1049.w;
|
|
|
|
let _e1054: vec4<f32> = temporary18_;
|
|
|
|
let _e1056: vec4<f32> = temporary18_;
|
|
|
|
temporary19_.y = dot(_e1054.xyz, _e1056.xyz);
|
|
|
|
let _e1061: vec4<f32> = temporary1_;
|
|
|
|
let _e1063: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = (_e1061.xxxx - _e1063.yyyy).x;
|
|
|
|
let _e1068: vec4<f32> = temporary19_;
|
|
|
|
let _e1070: vec4<f32> = temporary1_;
|
|
|
|
temporary13_.x = (_e1068.zzzz + _e1070.wwww).x;
|
|
|
|
let _e1075: vec4<f32> = temporary13_;
|
|
|
|
temporary1_.x = _e1075.xxxx.x;
|
|
|
|
let _e1081: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1083: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = vec4<f32>((_e1081.xxxx < _e1083.xxxx)).x;
|
|
|
|
let _e1089: vec4<f32> = temporary19_;
|
|
|
|
let _e1093: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1089.xxxx != _e1093.xxxx)) {
|
|
|
|
let _e1097: vec4<f32> = temporary1_;
|
|
|
|
temporary1_.x = sqrt(_e1097.xxxx).x;
|
|
|
|
let _e1102: vec4<f32> = temporary15_;
|
|
|
|
temporary19_.y = -(_e1102.zzzz).x;
|
|
|
|
let _e1107: vec4<f32> = temporary19_;
|
|
|
|
let _e1109: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.z = (_e1107.yyyy - _e1109.xxxx).x;
|
|
|
|
let _e1114: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.x = _e1114.zzzz.x;
|
|
|
|
let _e1120: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1122: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.y = vec4<f32>((_e1120.xxxx < _e1122.xxxx)).x;
|
|
|
|
let _e1128: vec4<f32> = temporary19_;
|
|
|
|
let _e1132: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1128.yyyy != _e1132.xxxx)) {
|
|
|
|
let _e1136: vec4<f32> = temporary19_;
|
|
|
|
temporary15_.y = _e1136.xxxx.x;
|
|
|
|
let _e1140: vec4<f32> = temporary10_;
|
|
|
|
let _e1142: vec4<f32> = temporary19_;
|
|
|
|
let _e1144: vec4<f32> = (_e1140.xyzz * _e1142.xxxx);
|
|
|
|
temporary13_.x = _e1144.x;
|
|
|
|
temporary13_.y = _e1144.y;
|
|
|
|
temporary13_.z = _e1144.z;
|
|
|
|
let _e1151: vec4<f32> = temporary5_;
|
|
|
|
let _e1153: vec4<f32> = temporary13_;
|
|
|
|
let _e1155: vec4<f32> = (_e1151.xyzz + _e1153.xyzz);
|
|
|
|
temporary12_.x = _e1155.x;
|
|
|
|
temporary12_.y = _e1155.y;
|
|
|
|
temporary12_.z = _e1155.z;
|
|
|
|
let _e1162: vec4<f32> = temporary12_;
|
|
|
|
let _e1164: vec4<f32> = temporary8_;
|
|
|
|
let _e1166: vec4<f32> = (_e1162.xyzz - _e1164.xyzz);
|
|
|
|
temporary14_.x = _e1166.x;
|
|
|
|
temporary14_.y = _e1166.y;
|
|
|
|
temporary14_.z = _e1166.z;
|
|
|
|
let _e1173: vec4<f32> = temporary14_;
|
|
|
|
let _e1175: vec3<f32> = normalize(_e1173.xyz);
|
|
|
|
temporary16_.x = _e1175.x;
|
|
|
|
temporary16_.y = _e1175.y;
|
|
|
|
temporary16_.z = _e1175.z;
|
|
|
|
let _e1182: vec4<f32> = temporary16_;
|
|
|
|
let _e1183: vec4<f32> = _e1182.xyzz;
|
|
|
|
temporary20_.x = _e1183.x;
|
|
|
|
temporary20_.y = _e1183.y;
|
|
|
|
temporary20_.z = _e1183.z;
|
|
|
|
let _e1190: vec4<f32> = temporary20_;
|
|
|
|
let _e1191: vec4<f32> = _e1190.xyzz;
|
|
|
|
temporary17_.x = _e1191.x;
|
|
|
|
temporary17_.y = _e1191.y;
|
|
|
|
temporary17_.z = _e1191.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1198: vec4<f32> = temporary15_;
|
|
|
|
temporary4_.y = _e1198.yyyy.x;
|
|
|
|
let _e1202: vec4<f32> = temporary17_;
|
|
|
|
let _e1203: vec4<f32> = _e1202.xyzz;
|
|
|
|
temporary3_.x = _e1203.x;
|
|
|
|
temporary3_.y = _e1203.y;
|
|
|
|
temporary3_.z = _e1203.z;
|
|
|
|
let _e1210: vec4<f32> = temporary4_;
|
|
|
|
let _e1212: vec4<f32> = temporary4_;
|
|
|
|
temporary1_.y = vec4<f32>((_e1210.yyyy < _e1212.zzzz)).x;
|
|
|
|
let _e1218: vec4<f32> = temporary1_;
|
|
|
|
let _e1222: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1218.yyyy != _e1222.xxxx)) {
|
|
|
|
let _e1226: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e1226.yyyy.x;
|
|
|
|
let _e1230: vec4<f32> = temporary3_;
|
|
|
|
let _e1231: vec4<f32> = _e1230.xyzz;
|
|
|
|
temporary6_.x = _e1231.x;
|
|
|
|
temporary6_.y = _e1231.y;
|
|
|
|
temporary6_.z = _e1231.z;
|
|
|
|
let _e1240: vec4<f32> = constant_registers[11u];
|
|
|
|
let _e1241: vec4<f32> = _e1240.xyzz;
|
|
|
|
temporary7_.x = _e1241.x;
|
|
|
|
temporary7_.y = _e1241.y;
|
|
|
|
temporary7_.z = _e1241.z;
|
|
|
|
let _e1250: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e1250.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1254: vec4<f32> = temporary11_;
|
|
|
|
let _e1258: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary11_.y = (_e1254.yyyy + _e1258.yyyy).x;
|
|
|
|
let _e1263: vec4<f32> = temporary1_;
|
|
|
|
let _e1267: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.y = vec4<f32>((_e1263.zzzz == _e1267.xxxx)).x;
|
|
|
|
let _e1273: vec4<f32> = temporary1_;
|
|
|
|
let _e1277: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1273.yyyy != _e1277.xxxx)) {
|
|
|
|
let _e1283: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1284: vec4<f32> = _e1283.xyyy;
|
|
|
|
temporary11_.x = _e1284.x;
|
|
|
|
temporary11_.z = _e1284.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
} else {
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1289: vec4<f32> = temporary9_;
|
|
|
|
let _e1291: vec4<f32> = temporary4_;
|
|
|
|
let _e1293: vec4<f32> = (_e1289.xyzz * _e1291.zzzz);
|
|
|
|
temporary5_.x = _e1293.x;
|
|
|
|
temporary5_.y = _e1293.y;
|
|
|
|
temporary5_.z = _e1293.z;
|
|
|
|
let _e1300: vec4<f32> = temporary2_;
|
|
|
|
let _e1302: vec4<f32> = temporary5_;
|
|
|
|
let _e1304: vec4<f32> = (_e1300.xyzz + _e1302.xyzz);
|
|
|
|
temporary2_.x = _e1304.x;
|
|
|
|
temporary2_.y = _e1304.y;
|
|
|
|
temporary2_.z = _e1304.z;
|
|
|
|
let _e1311: vec4<f32> = temporary9_;
|
|
|
|
let _e1313: vec4<f32> = temporary6_;
|
|
|
|
temporary1_.y = dot(_e1311.xyz, _e1313.xyz);
|
|
|
|
let _e1317: vec4<f32> = temporary1_;
|
|
|
|
let _e1321: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary5_.x = (_e1317.yyyy * _e1321.xxxx).x;
|
|
|
|
let _e1326: vec4<f32> = temporary5_;
|
|
|
|
let _e1328: vec4<f32> = temporary6_;
|
|
|
|
let _e1330: vec4<f32> = (_e1326.xxxx * _e1328.xyzz);
|
|
|
|
temporary10_.x = _e1330.x;
|
|
|
|
temporary10_.y = _e1330.y;
|
|
|
|
temporary10_.z = _e1330.z;
|
|
|
|
let _e1337: vec4<f32> = temporary9_;
|
|
|
|
let _e1339: vec4<f32> = temporary10_;
|
|
|
|
let _e1341: vec4<f32> = (_e1337.xyzz - _e1339.xyzz);
|
|
|
|
temporary9_.x = _e1341.x;
|
|
|
|
temporary9_.y = _e1341.y;
|
|
|
|
temporary9_.z = _e1341.z;
|
|
|
|
let _e1348: vec4<f32> = temporary9_;
|
|
|
|
let _e1352: vec4<f32> = constant_registers[18u];
|
|
|
|
let _e1354: vec4<f32> = (_e1348.xyzz * _e1352.yyyy);
|
|
|
|
temporary5_.x = _e1354.x;
|
|
|
|
temporary5_.y = _e1354.y;
|
|
|
|
temporary5_.z = _e1354.z;
|
|
|
|
let _e1361: vec4<f32> = temporary2_;
|
|
|
|
let _e1363: vec4<f32> = temporary5_;
|
|
|
|
let _e1365: vec4<f32> = (_e1361.xyzz + _e1363.xyzz);
|
|
|
|
temporary2_.x = _e1365.x;
|
|
|
|
temporary2_.y = _e1365.y;
|
|
|
|
temporary2_.z = _e1365.z;
|
|
|
|
let _e1374: vec4<f32> = constant_registers[15u];
|
|
|
|
let _e1376: vec4<f32> = temporary2_;
|
|
|
|
let _e1378: vec4<f32> = (_e1374.xyzz - _e1376.xyzz);
|
|
|
|
temporary5_.x = _e1378.x;
|
|
|
|
temporary5_.y = _e1378.y;
|
|
|
|
temporary5_.z = _e1378.z;
|
|
|
|
let _e1385: vec4<f32> = temporary5_;
|
|
|
|
let _e1387: vec3<f32> = normalize(_e1385.xyz);
|
|
|
|
temporary10_.x = _e1387.x;
|
|
|
|
temporary10_.y = _e1387.y;
|
|
|
|
temporary10_.z = _e1387.z;
|
|
|
|
let _e1394: vec4<f32> = temporary5_;
|
|
|
|
let _e1396: vec4<f32> = temporary5_;
|
|
|
|
temporary8_.x = dot(_e1394.xyz, _e1396.xyz);
|
|
|
|
let _e1400: vec4<f32> = temporary8_;
|
|
|
|
temporary1_.y = sqrt(_e1400.xxxx).x;
|
|
|
|
let _e1405: vec4<f32> = temporary6_;
|
|
|
|
let _e1407: vec4<f32> = temporary10_;
|
|
|
|
temporary8_.y = dot(_e1405.xyz, _e1407.xyz);
|
|
|
|
let _e1411: vec4<f32> = temporary8_;
|
|
|
|
temporary8_.z = saturate(_e1411.yyyy).x;
|
|
|
|
let _e1416: vec4<f32> = temporary1_;
|
|
|
|
let _e1418: vec4<f32> = temporary1_;
|
|
|
|
temporary2_.w = (_e1416.yyyy * _e1418.yyyy).x;
|
|
|
|
let _e1423: vec4<f32> = temporary2_;
|
|
|
|
let _e1427: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary15_.x = (_e1423.wwww * _e1427.zzzz).x;
|
|
|
|
let _e1434: vec4<f32> = constant_registers[18u];
|
|
|
|
let _e1436: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.y = (_e1434.wwww + _e1436.xxxx).x;
|
|
|
|
let _e1441: vec4<f32> = temporary8_;
|
|
|
|
let _e1443: vec4<f32> = temporary15_;
|
|
|
|
temporary8_.x = (_e1441.zzzz / _e1443.yyyy).x;
|
|
|
|
let _e1450: vec4<f32> = constant_registers[6u];
|
|
|
|
temporary8_.z = _e1450.xxxx.x;
|
|
|
|
let _e1456: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary2_.w = _e1456.wwww.x;
|
|
|
|
let _e1460: vec4<f32> = temporary2_;
|
|
|
|
let _e1464: vec4<f32> = constant_registers[4u];
|
|
|
|
let _e1466: vec4<f32> = (_e1460.xyzz - _e1464.xyzz);
|
|
|
|
temporary19_.x = _e1466.x;
|
|
|
|
temporary19_.y = _e1466.y;
|
|
|
|
temporary19_.z = _e1466.z;
|
|
|
|
let _e1473: vec4<f32> = temporary19_;
|
|
|
|
let _e1475: vec4<f32> = temporary10_;
|
|
|
|
temporary13_.x = dot(_e1473.xyz, _e1475.xyz);
|
|
|
|
let _e1479: vec4<f32> = temporary13_;
|
|
|
|
let _e1481: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = (_e1479.xxxx * _e1481.xxxx).x;
|
|
|
|
let _e1486: vec4<f32> = temporary19_;
|
|
|
|
let _e1488: vec4<f32> = temporary19_;
|
|
|
|
temporary3_.w = dot(_e1486.xyz, _e1488.xyz);
|
|
|
|
let _e1492: vec4<f32> = temporary13_;
|
|
|
|
let _e1494: vec4<f32> = temporary3_;
|
|
|
|
temporary12_.x = (_e1492.zzzz - _e1494.wwww).x;
|
|
|
|
let _e1499: vec4<f32> = temporary8_;
|
|
|
|
let _e1501: vec4<f32> = temporary8_;
|
|
|
|
temporary12_.y = (_e1499.zzzz * _e1501.zzzz).x;
|
|
|
|
let _e1506: vec4<f32> = temporary12_;
|
|
|
|
let _e1508: vec4<f32> = temporary12_;
|
|
|
|
temporary13_.y = (_e1506.xxxx + _e1508.yyyy).x;
|
|
|
|
let _e1515: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1517: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = vec4<f32>((_e1515.xxxx < _e1517.yyyy)).x;
|
|
|
|
let _e1523: vec4<f32> = temporary13_;
|
|
|
|
let _e1527: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1523.zzzz != _e1527.xxxx)) {
|
|
|
|
let _e1531: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.y = sqrt(_e1531.yyyy).x;
|
|
|
|
let _e1536: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = -(_e1536.xxxx).x;
|
|
|
|
let _e1541: vec4<f32> = temporary3_;
|
|
|
|
let _e1543: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = (_e1541.wwww - _e1543.yyyy).x;
|
|
|
|
let _e1550: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1552: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e1550.xxxx < _e1552.zzzz)).x;
|
|
|
|
let _e1558: vec4<f32> = temporary3_;
|
|
|
|
let _e1562: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1558.wwww != _e1562.xxxx)) {
|
|
|
|
let _e1566: vec4<f32> = temporary13_;
|
|
|
|
temporary2_.w = _e1566.zzzz.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1570: vec4<f32> = temporary2_;
|
|
|
|
let _e1572: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.y = vec4<f32>((_e1570.wwww < _e1572.yyyy)).x;
|
|
|
|
let _e1578: vec4<f32> = temporary8_;
|
|
|
|
let _e1582: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1578.yyyy != _e1582.xxxx)) {
|
|
|
|
let _e1588: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e1588.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1594: vec4<f32> = constant_registers[9u];
|
|
|
|
temporary8_.z = _e1594.xxxx.x;
|
|
|
|
let _e1600: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary2_.w = _e1600.wwww.x;
|
|
|
|
let _e1604: vec4<f32> = temporary2_;
|
|
|
|
let _e1608: vec4<f32> = constant_registers[7u];
|
|
|
|
let _e1610: vec4<f32> = (_e1604.xyzz - _e1608.xyzz);
|
|
|
|
temporary19_.x = _e1610.x;
|
|
|
|
temporary19_.y = _e1610.y;
|
|
|
|
temporary19_.z = _e1610.z;
|
|
|
|
let _e1617: vec4<f32> = temporary19_;
|
|
|
|
let _e1619: vec4<f32> = temporary10_;
|
|
|
|
temporary13_.x = dot(_e1617.xyz, _e1619.xyz);
|
|
|
|
let _e1623: vec4<f32> = temporary13_;
|
|
|
|
let _e1625: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = (_e1623.xxxx * _e1625.xxxx).x;
|
|
|
|
let _e1630: vec4<f32> = temporary19_;
|
|
|
|
let _e1632: vec4<f32> = temporary19_;
|
|
|
|
temporary3_.w = dot(_e1630.xyz, _e1632.xyz);
|
|
|
|
let _e1636: vec4<f32> = temporary13_;
|
|
|
|
let _e1638: vec4<f32> = temporary3_;
|
|
|
|
temporary12_.x = (_e1636.zzzz - _e1638.wwww).x;
|
|
|
|
let _e1643: vec4<f32> = temporary8_;
|
|
|
|
let _e1645: vec4<f32> = temporary8_;
|
|
|
|
temporary12_.y = (_e1643.zzzz * _e1645.zzzz).x;
|
|
|
|
let _e1650: vec4<f32> = temporary12_;
|
|
|
|
let _e1652: vec4<f32> = temporary12_;
|
|
|
|
temporary13_.y = (_e1650.xxxx + _e1652.yyyy).x;
|
|
|
|
let _e1659: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1661: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = vec4<f32>((_e1659.xxxx < _e1661.yyyy)).x;
|
|
|
|
let _e1667: vec4<f32> = temporary13_;
|
|
|
|
let _e1671: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1667.zzzz != _e1671.xxxx)) {
|
|
|
|
let _e1675: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.y = sqrt(_e1675.yyyy).x;
|
|
|
|
let _e1680: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = -(_e1680.xxxx).x;
|
|
|
|
let _e1685: vec4<f32> = temporary3_;
|
|
|
|
let _e1687: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = (_e1685.wwww - _e1687.yyyy).x;
|
|
|
|
let _e1694: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1696: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e1694.xxxx < _e1696.zzzz)).x;
|
|
|
|
let _e1702: vec4<f32> = temporary3_;
|
|
|
|
let _e1706: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1702.wwww != _e1706.xxxx)) {
|
|
|
|
let _e1710: vec4<f32> = temporary13_;
|
|
|
|
temporary2_.w = _e1710.zzzz.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1714: vec4<f32> = temporary2_;
|
|
|
|
let _e1716: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.y = vec4<f32>((_e1714.wwww < _e1716.yyyy)).x;
|
|
|
|
let _e1722: vec4<f32> = temporary8_;
|
|
|
|
let _e1726: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1722.yyyy != _e1726.xxxx)) {
|
|
|
|
let _e1732: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e1732.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1736: vec4<f32> = temporary2_;
|
|
|
|
let _e1737: vec4<f32> = _e1736.xyzz;
|
|
|
|
temporary15_.x = _e1737.x;
|
|
|
|
temporary15_.y = _e1737.y;
|
|
|
|
temporary15_.z = _e1737.z;
|
|
|
|
let _e1744: vec4<f32> = temporary10_;
|
|
|
|
let _e1745: vec4<f32> = _e1744.xyzz;
|
|
|
|
temporary17_.x = _e1745.x;
|
|
|
|
temporary17_.y = _e1745.y;
|
|
|
|
temporary17_.z = _e1745.z;
|
|
|
|
let _e1754: vec4<f32> = constant_registers[10u];
|
|
|
|
let _e1755: vec4<f32> = _e1754.xyzz;
|
|
|
|
temporary18_.x = _e1755.x;
|
|
|
|
temporary18_.y = _e1755.y;
|
|
|
|
temporary18_.z = _e1755.z;
|
|
|
|
let _e1764: vec4<f32> = constant_registers[12u];
|
|
|
|
temporary8_.z = _e1764.xxxx.x;
|
|
|
|
let _e1770: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary2_.w = _e1770.wwww.x;
|
|
|
|
let _e1774: vec4<f32> = temporary15_;
|
|
|
|
let _e1776: vec4<f32> = temporary18_;
|
|
|
|
let _e1778: vec4<f32> = (_e1774.xyzz - _e1776.xyzz);
|
|
|
|
temporary19_.x = _e1778.x;
|
|
|
|
temporary19_.y = _e1778.y;
|
|
|
|
temporary19_.z = _e1778.z;
|
|
|
|
let _e1785: vec4<f32> = temporary19_;
|
|
|
|
let _e1787: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.x = dot(_e1785.xyz, _e1787.xyz);
|
|
|
|
let _e1791: vec4<f32> = temporary13_;
|
|
|
|
let _e1793: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = (_e1791.xxxx * _e1793.xxxx).x;
|
|
|
|
let _e1798: vec4<f32> = temporary19_;
|
|
|
|
let _e1800: vec4<f32> = temporary19_;
|
|
|
|
temporary3_.w = dot(_e1798.xyz, _e1800.xyz);
|
|
|
|
let _e1804: vec4<f32> = temporary13_;
|
|
|
|
let _e1806: vec4<f32> = temporary3_;
|
|
|
|
temporary12_.x = (_e1804.zzzz - _e1806.wwww).x;
|
|
|
|
let _e1811: vec4<f32> = temporary8_;
|
|
|
|
let _e1813: vec4<f32> = temporary8_;
|
|
|
|
temporary12_.y = (_e1811.zzzz * _e1813.zzzz).x;
|
|
|
|
let _e1818: vec4<f32> = temporary12_;
|
|
|
|
let _e1820: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.z = (_e1818.xxxx + _e1820.yyyy).x;
|
|
|
|
let _e1825: vec4<f32> = temporary12_;
|
|
|
|
temporary13_.y = _e1825.zzzz.x;
|
|
|
|
let _e1831: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1833: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = vec4<f32>((_e1831.xxxx < _e1833.yyyy)).x;
|
|
|
|
let _e1839: vec4<f32> = temporary13_;
|
|
|
|
let _e1843: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1839.zzzz != _e1843.xxxx)) {
|
|
|
|
let _e1847: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.y = sqrt(_e1847.yyyy).x;
|
|
|
|
let _e1852: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = -(_e1852.xxxx).x;
|
|
|
|
let _e1857: vec4<f32> = temporary3_;
|
|
|
|
let _e1859: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = (_e1857.wwww - _e1859.yyyy).x;
|
|
|
|
let _e1864: vec4<f32> = temporary12_;
|
|
|
|
temporary13_.z = _e1864.xxxx.x;
|
|
|
|
let _e1870: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e1872: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e1870.xxxx < _e1872.zzzz)).x;
|
|
|
|
let _e1878: vec4<f32> = temporary3_;
|
|
|
|
let _e1882: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1878.wwww != _e1882.xxxx)) {
|
|
|
|
let _e1886: vec4<f32> = temporary13_;
|
|
|
|
temporary2_.w = _e1886.zzzz.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1890: vec4<f32> = temporary2_;
|
|
|
|
temporary4_.y = _e1890.wwww.x;
|
|
|
|
let _e1894: vec4<f32> = temporary4_;
|
|
|
|
let _e1896: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.y = vec4<f32>((_e1894.yyyy < _e1896.yyyy)).x;
|
|
|
|
let _e1902: vec4<f32> = temporary8_;
|
|
|
|
let _e1906: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1902.yyyy != _e1906.xxxx)) {
|
|
|
|
let _e1912: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e1912.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e1916: vec4<f32> = temporary6_;
|
|
|
|
temporary8_.y = saturate(_e1916.yyyy).x;
|
|
|
|
let _e1921: vec4<f32> = temporary8_;
|
|
|
|
let _e1925: vec4<f32> = constant_registers[19u];
|
|
|
|
temporary8_.z = (_e1921.yyyy * _e1925.xxxx).x;
|
|
|
|
let _e1930: vec4<f32> = temporary8_;
|
|
|
|
let _e1932: vec4<f32> = temporary8_;
|
|
|
|
temporary8_.x = (_e1930.xxxx + _e1932.zzzz).x;
|
|
|
|
let _e1937: vec4<f32> = temporary8_;
|
|
|
|
let _e1941: vec4<f32> = constant_registers[19u];
|
|
|
|
temporary8_.z = (_e1937.xxxx * _e1941.yyyy).x;
|
|
|
|
let _e1948: vec4<f32> = constant_registers[19u];
|
|
|
|
let _e1950: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = (_e1948.zzzz + _e1950.zzzz).x;
|
|
|
|
let _e1955: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.y = _e1955.wwww.x;
|
|
|
|
let _e1959: vec4<f32> = temporary1_;
|
|
|
|
let _e1963: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.z = vec4<f32>((_e1959.zzzz == _e1963.yyyy)).x;
|
|
|
|
let _e1969: vec4<f32> = temporary8_;
|
|
|
|
let _e1973: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e1969.zzzz != _e1973.xxxx)) {
|
|
|
|
let _e1977: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.z = fract(_e1977.xxxx).x;
|
|
|
|
let _e1982: vec4<f32> = temporary2_;
|
|
|
|
let _e1984: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = (_e1982.xxxx - _e1984.zzzz).x;
|
|
|
|
let _e1989: vec4<f32> = temporary2_;
|
|
|
|
temporary15_.x = fract(_e1989.zzzz).x;
|
|
|
|
let _e1994: vec4<f32> = temporary2_;
|
|
|
|
let _e1996: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.y = (_e1994.zzzz - _e1996.xxxx).x;
|
|
|
|
let _e2001: vec4<f32> = temporary2_;
|
|
|
|
let _e2003: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.z = (_e2001.wwww + _e2003.yyyy).x;
|
|
|
|
let _e2008: vec4<f32> = temporary15_;
|
|
|
|
let _e2012: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.x = (_e2008.zzzz / _e2012.xxxx).x;
|
|
|
|
let _e2017: vec4<f32> = temporary1_;
|
|
|
|
temporary17_.x = fract(_e2017.xxxx).x;
|
|
|
|
let _e2022: vec4<f32> = temporary17_;
|
|
|
|
let _e2026: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary17_.y = (_e2022.xxxx * _e2026.xxxx).x;
|
|
|
|
let _e2031: vec4<f32> = temporary17_;
|
|
|
|
let _e2035: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary17_.z = vec4<f32>((_e2031.yyyy == _e2035.yyyy)).x;
|
|
|
|
let _e2041: vec4<f32> = temporary17_;
|
|
|
|
let _e2045: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2041.zzzz != _e2045.xxxx)) {
|
|
|
|
let _e2051: vec4<f32> = constant_registers[13u];
|
|
|
|
let _e2053: vec4<f32> = temporary8_;
|
|
|
|
let _e2055: vec4<f32> = (_e2051.xyzz * _e2053.yyyy);
|
|
|
|
temporary15_.x = _e2055.x;
|
|
|
|
temporary15_.y = _e2055.y;
|
|
|
|
temporary15_.z = _e2055.z;
|
|
|
|
let _e2062: vec4<f32> = temporary0_;
|
|
|
|
let _e2064: vec4<f32> = temporary15_;
|
|
|
|
let _e2066: vec4<f32> = (_e2062.xyzz + _e2064.xyzz);
|
|
|
|
temporary0_.x = _e2066.x;
|
|
|
|
temporary0_.y = _e2066.y;
|
|
|
|
temporary0_.z = _e2066.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
} else {
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2075: vec4<f32> = constant_registers[14u];
|
|
|
|
let _e2077: vec4<f32> = temporary8_;
|
|
|
|
let _e2079: vec4<f32> = (_e2075.xyzz * _e2077.yyyy);
|
|
|
|
temporary15_.x = _e2079.x;
|
|
|
|
temporary15_.y = _e2079.y;
|
|
|
|
temporary15_.z = _e2079.z;
|
|
|
|
let _e2086: vec4<f32> = temporary0_;
|
|
|
|
let _e2088: vec4<f32> = temporary15_;
|
|
|
|
let _e2090: vec4<f32> = (_e2086.xyzz + _e2088.xyzz);
|
|
|
|
temporary0_.x = _e2090.x;
|
|
|
|
temporary0_.y = _e2090.y;
|
|
|
|
temporary0_.z = _e2090.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2097: vec4<f32> = temporary1_;
|
|
|
|
let _e2101: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary8_.z = vec4<f32>((_e2097.zzzz == _e2101.xxxx)).x;
|
|
|
|
let _e2107: vec4<f32> = temporary8_;
|
|
|
|
let _e2111: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2107.zzzz != _e2111.xxxx)) {
|
|
|
|
let _e2115: vec4<f32> = temporary7_;
|
|
|
|
let _e2117: vec4<f32> = temporary8_;
|
|
|
|
let _e2119: vec4<f32> = (_e2115.xyzz * _e2117.yyyy);
|
|
|
|
temporary15_.x = _e2119.x;
|
|
|
|
temporary15_.y = _e2119.y;
|
|
|
|
temporary15_.z = _e2119.z;
|
|
|
|
let _e2126: vec4<f32> = temporary0_;
|
|
|
|
let _e2128: vec4<f32> = temporary15_;
|
|
|
|
let _e2130: vec4<f32> = (_e2126.xyzz + _e2128.xyzz);
|
|
|
|
temporary0_.x = _e2130.x;
|
|
|
|
temporary0_.y = _e2130.y;
|
|
|
|
temporary0_.z = _e2130.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2139: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary11_.x = _e2139.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2143: vec4<f32> = temporary11_;
|
|
|
|
let _e2147: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2143.xxxx != _e2147.xxxx)) {
|
|
|
|
let _e2153: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = _e2153.xxxx.x;
|
|
|
|
let _e2159: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary4_.z = _e2159.wwww.x;
|
|
|
|
let _e2165: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2166: vec4<f32> = _e2165.xyxx;
|
|
|
|
temporary3_.x = _e2166.x;
|
|
|
|
temporary3_.y = _e2166.y;
|
|
|
|
temporary3_.z = _e2166.z;
|
|
|
|
let _e2173: vec4<f32> = temporary3_;
|
|
|
|
let _e2174: vec4<f32> = _e2173.xyzz;
|
|
|
|
temporary12_.x = _e2174.x;
|
|
|
|
temporary12_.y = _e2174.y;
|
|
|
|
temporary12_.z = _e2174.z;
|
|
|
|
let _e2183: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary2_.w = _e2183.wwww.x;
|
|
|
|
let _e2187: vec4<f32> = temporary2_;
|
|
|
|
let _e2191: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2193: vec4<f32> = (_e2187.xyzz - _e2191.xxxx);
|
|
|
|
temporary20_.x = _e2193.x;
|
|
|
|
temporary20_.y = _e2193.y;
|
|
|
|
temporary20_.z = _e2193.z;
|
|
|
|
let _e2200: vec4<f32> = temporary20_;
|
|
|
|
let _e2202: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.y = dot(_e2200.xyz, _e2202.xyz);
|
|
|
|
let _e2206: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.z = -(_e2206.yyyy).x;
|
|
|
|
let _e2211: vec4<f32> = temporary9_;
|
|
|
|
let _e2213: vec4<f32> = temporary12_;
|
|
|
|
temporary4_.x = dot(_e2211.xyz, _e2213.xyz);
|
|
|
|
let _e2217: vec4<f32> = temporary14_;
|
|
|
|
let _e2219: vec4<f32> = temporary4_;
|
|
|
|
temporary16_.x = (_e2217.zzzz / _e2219.xxxx).x;
|
|
|
|
let _e2224: vec4<f32> = temporary16_;
|
|
|
|
temporary14_.x = _e2224.xxxx.x;
|
|
|
|
let _e2230: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2232: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = vec4<f32>((_e2230.xxxx < _e2232.xxxx)).x;
|
|
|
|
let _e2238: vec4<f32> = temporary14_;
|
|
|
|
let _e2242: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2238.yyyy != _e2242.xxxx)) {
|
|
|
|
let _e2246: vec4<f32> = temporary14_;
|
|
|
|
temporary2_.w = _e2246.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2250: vec4<f32> = temporary2_;
|
|
|
|
temporary4_.y = _e2250.wwww.x;
|
|
|
|
let _e2254: vec4<f32> = temporary4_;
|
|
|
|
let _e2256: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e2254.yyyy < _e2256.zzzz)).x;
|
|
|
|
let _e2262: vec4<f32> = temporary8_;
|
|
|
|
let _e2266: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2262.zzzz != _e2266.xxxx)) {
|
|
|
|
let _e2270: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e2270.yyyy.x;
|
|
|
|
let _e2274: vec4<f32> = temporary3_;
|
|
|
|
let _e2275: vec4<f32> = _e2274.xyzz;
|
|
|
|
temporary6_.x = _e2275.x;
|
|
|
|
temporary6_.y = _e2275.y;
|
|
|
|
temporary6_.z = _e2275.z;
|
|
|
|
let _e2284: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = _e2284.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2288: vec4<f32> = temporary2_;
|
|
|
|
let _e2289: vec4<f32> = _e2288.xyzz;
|
|
|
|
temporary15_.x = _e2289.x;
|
|
|
|
temporary15_.y = _e2289.y;
|
|
|
|
temporary15_.z = _e2289.z;
|
|
|
|
let _e2296: vec4<f32> = temporary9_;
|
|
|
|
let _e2297: vec4<f32> = _e2296.xyzz;
|
|
|
|
temporary17_.x = _e2297.x;
|
|
|
|
temporary17_.y = _e2297.y;
|
|
|
|
temporary17_.z = _e2297.z;
|
|
|
|
let _e2306: vec4<f32> = constant_registers[4u];
|
|
|
|
let _e2307: vec4<f32> = _e2306.xyzz;
|
|
|
|
temporary18_.x = _e2307.x;
|
|
|
|
temporary18_.y = _e2307.y;
|
|
|
|
temporary18_.z = _e2307.z;
|
|
|
|
let _e2316: vec4<f32> = constant_registers[6u];
|
|
|
|
temporary2_.w = _e2316.xxxx.x;
|
|
|
|
let _e2320: vec4<f32> = temporary3_;
|
|
|
|
let _e2321: vec4<f32> = _e2320.xyzz;
|
|
|
|
temporary19_.x = _e2321.x;
|
|
|
|
temporary19_.y = _e2321.y;
|
|
|
|
temporary19_.z = _e2321.z;
|
|
|
|
let _e2330: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary13_.x = _e2330.wwww.x;
|
|
|
|
let _e2334: vec4<f32> = temporary15_;
|
|
|
|
let _e2336: vec4<f32> = temporary18_;
|
|
|
|
let _e2338: vec4<f32> = (_e2334.xyzz - _e2336.xyzz);
|
|
|
|
temporary12_.x = _e2338.x;
|
|
|
|
temporary12_.y = _e2338.y;
|
|
|
|
temporary12_.z = _e2338.z;
|
|
|
|
let _e2345: vec4<f32> = temporary12_;
|
|
|
|
let _e2347: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.y = dot(_e2345.xyz, _e2347.xyz);
|
|
|
|
let _e2351: vec4<f32> = temporary13_;
|
|
|
|
let _e2353: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = (_e2351.yyyy * _e2353.yyyy).x;
|
|
|
|
let _e2358: vec4<f32> = temporary12_;
|
|
|
|
let _e2360: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.x = dot(_e2358.xyz, _e2360.xyz);
|
|
|
|
let _e2364: vec4<f32> = temporary3_;
|
|
|
|
let _e2366: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = (_e2364.wwww - _e2366.xxxx).x;
|
|
|
|
let _e2371: vec4<f32> = temporary2_;
|
|
|
|
let _e2373: vec4<f32> = temporary2_;
|
|
|
|
temporary14_.z = (_e2371.wwww * _e2373.wwww).x;
|
|
|
|
let _e2378: vec4<f32> = temporary14_;
|
|
|
|
let _e2380: vec4<f32> = temporary14_;
|
|
|
|
temporary13_.z = (_e2378.yyyy + _e2380.zzzz).x;
|
|
|
|
let _e2387: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2389: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e2387.xxxx < _e2389.zzzz)).x;
|
|
|
|
let _e2395: vec4<f32> = temporary3_;
|
|
|
|
let _e2399: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2395.wwww != _e2399.xxxx)) {
|
|
|
|
let _e2403: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = sqrt(_e2403.zzzz).x;
|
|
|
|
let _e2408: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.x = -(_e2408.yyyy).x;
|
|
|
|
let _e2413: vec4<f32> = temporary14_;
|
|
|
|
let _e2415: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.y = (_e2413.xxxx - _e2415.zzzz).x;
|
|
|
|
let _e2420: vec4<f32> = temporary14_;
|
|
|
|
temporary3_.w = _e2420.yyyy.x;
|
|
|
|
let _e2426: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2428: vec4<f32> = temporary3_;
|
|
|
|
temporary14_.x = vec4<f32>((_e2426.xxxx < _e2428.wwww)).x;
|
|
|
|
let _e2434: vec4<f32> = temporary14_;
|
|
|
|
let _e2438: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2434.xxxx != _e2438.xxxx)) {
|
|
|
|
let _e2442: vec4<f32> = temporary3_;
|
|
|
|
temporary13_.x = _e2442.wwww.x;
|
|
|
|
let _e2446: vec4<f32> = temporary17_;
|
|
|
|
let _e2448: vec4<f32> = temporary3_;
|
|
|
|
let _e2450: vec4<f32> = (_e2446.xyzz * _e2448.wwww);
|
|
|
|
temporary14_.x = _e2450.x;
|
|
|
|
temporary14_.y = _e2450.y;
|
|
|
|
temporary14_.z = _e2450.z;
|
|
|
|
let _e2457: vec4<f32> = temporary15_;
|
|
|
|
let _e2459: vec4<f32> = temporary14_;
|
|
|
|
let _e2461: vec4<f32> = (_e2457.xyzz + _e2459.xyzz);
|
|
|
|
temporary20_.x = _e2461.x;
|
|
|
|
temporary20_.y = _e2461.y;
|
|
|
|
temporary20_.z = _e2461.z;
|
|
|
|
let _e2468: vec4<f32> = temporary20_;
|
|
|
|
let _e2470: vec4<f32> = temporary18_;
|
|
|
|
let _e2472: vec4<f32> = (_e2468.xyzz - _e2470.xyzz);
|
|
|
|
temporary16_.x = _e2472.x;
|
|
|
|
temporary16_.y = _e2472.y;
|
|
|
|
temporary16_.z = _e2472.z;
|
|
|
|
let _e2479: vec4<f32> = temporary16_;
|
|
|
|
let _e2481: vec3<f32> = normalize(_e2479.xyz);
|
|
|
|
temporary19_.x = _e2481.x;
|
|
|
|
temporary19_.y = _e2481.y;
|
|
|
|
temporary19_.z = _e2481.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2488: vec4<f32> = temporary13_;
|
|
|
|
temporary4_.y = _e2488.xxxx.x;
|
|
|
|
let _e2492: vec4<f32> = temporary19_;
|
|
|
|
let _e2493: vec4<f32> = _e2492.xyzz;
|
|
|
|
temporary3_.x = _e2493.x;
|
|
|
|
temporary3_.y = _e2493.y;
|
|
|
|
temporary3_.z = _e2493.z;
|
|
|
|
let _e2500: vec4<f32> = temporary4_;
|
|
|
|
let _e2502: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e2500.yyyy < _e2502.zzzz)).x;
|
|
|
|
let _e2508: vec4<f32> = temporary8_;
|
|
|
|
let _e2512: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2508.zzzz != _e2512.xxxx)) {
|
|
|
|
let _e2516: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e2516.yyyy.x;
|
|
|
|
let _e2520: vec4<f32> = temporary3_;
|
|
|
|
let _e2521: vec4<f32> = _e2520.xyzz;
|
|
|
|
temporary6_.x = _e2521.x;
|
|
|
|
temporary6_.y = _e2521.y;
|
|
|
|
temporary6_.z = _e2521.z;
|
|
|
|
let _e2530: vec4<f32> = constant_registers[5u];
|
|
|
|
let _e2531: vec4<f32> = _e2530.xyzz;
|
|
|
|
temporary7_.x = _e2531.x;
|
|
|
|
temporary7_.y = _e2531.y;
|
|
|
|
temporary7_.z = _e2531.z;
|
|
|
|
let _e2540: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e2540.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2544: vec4<f32> = temporary2_;
|
|
|
|
let _e2545: vec4<f32> = _e2544.xyzz;
|
|
|
|
temporary15_.x = _e2545.x;
|
|
|
|
temporary15_.y = _e2545.y;
|
|
|
|
temporary15_.z = _e2545.z;
|
|
|
|
let _e2552: vec4<f32> = temporary9_;
|
|
|
|
let _e2553: vec4<f32> = _e2552.xyzz;
|
|
|
|
temporary17_.x = _e2553.x;
|
|
|
|
temporary17_.y = _e2553.y;
|
|
|
|
temporary17_.z = _e2553.z;
|
|
|
|
let _e2562: vec4<f32> = constant_registers[7u];
|
|
|
|
let _e2563: vec4<f32> = _e2562.xyzz;
|
|
|
|
temporary18_.x = _e2563.x;
|
|
|
|
temporary18_.y = _e2563.y;
|
|
|
|
temporary18_.z = _e2563.z;
|
|
|
|
let _e2572: vec4<f32> = constant_registers[9u];
|
|
|
|
temporary2_.w = _e2572.xxxx.x;
|
|
|
|
let _e2576: vec4<f32> = temporary3_;
|
|
|
|
let _e2577: vec4<f32> = _e2576.xyzz;
|
|
|
|
temporary19_.x = _e2577.x;
|
|
|
|
temporary19_.y = _e2577.y;
|
|
|
|
temporary19_.z = _e2577.z;
|
|
|
|
let _e2586: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary13_.x = _e2586.wwww.x;
|
|
|
|
let _e2590: vec4<f32> = temporary15_;
|
|
|
|
let _e2592: vec4<f32> = temporary18_;
|
|
|
|
let _e2594: vec4<f32> = (_e2590.xyzz - _e2592.xyzz);
|
|
|
|
temporary12_.x = _e2594.x;
|
|
|
|
temporary12_.y = _e2594.y;
|
|
|
|
temporary12_.z = _e2594.z;
|
|
|
|
let _e2601: vec4<f32> = temporary12_;
|
|
|
|
let _e2603: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.y = dot(_e2601.xyz, _e2603.xyz);
|
|
|
|
let _e2607: vec4<f32> = temporary13_;
|
|
|
|
let _e2609: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = (_e2607.yyyy * _e2609.yyyy).x;
|
|
|
|
let _e2614: vec4<f32> = temporary12_;
|
|
|
|
let _e2616: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.x = dot(_e2614.xyz, _e2616.xyz);
|
|
|
|
let _e2620: vec4<f32> = temporary3_;
|
|
|
|
let _e2622: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = (_e2620.wwww - _e2622.xxxx).x;
|
|
|
|
let _e2627: vec4<f32> = temporary2_;
|
|
|
|
let _e2629: vec4<f32> = temporary2_;
|
|
|
|
temporary14_.z = (_e2627.wwww * _e2629.wwww).x;
|
|
|
|
let _e2634: vec4<f32> = temporary14_;
|
|
|
|
let _e2636: vec4<f32> = temporary14_;
|
|
|
|
temporary13_.z = (_e2634.yyyy + _e2636.zzzz).x;
|
|
|
|
let _e2643: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2645: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e2643.xxxx < _e2645.zzzz)).x;
|
|
|
|
let _e2651: vec4<f32> = temporary3_;
|
|
|
|
let _e2655: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2651.wwww != _e2655.xxxx)) {
|
|
|
|
let _e2659: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = sqrt(_e2659.zzzz).x;
|
|
|
|
let _e2664: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.x = -(_e2664.yyyy).x;
|
|
|
|
let _e2669: vec4<f32> = temporary14_;
|
|
|
|
let _e2671: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.y = (_e2669.xxxx - _e2671.zzzz).x;
|
|
|
|
let _e2676: vec4<f32> = temporary14_;
|
|
|
|
temporary3_.w = _e2676.yyyy.x;
|
|
|
|
let _e2682: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2684: vec4<f32> = temporary3_;
|
|
|
|
temporary14_.x = vec4<f32>((_e2682.xxxx < _e2684.wwww)).x;
|
|
|
|
let _e2690: vec4<f32> = temporary14_;
|
|
|
|
let _e2694: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2690.xxxx != _e2694.xxxx)) {
|
|
|
|
let _e2698: vec4<f32> = temporary3_;
|
|
|
|
temporary13_.x = _e2698.wwww.x;
|
|
|
|
let _e2702: vec4<f32> = temporary17_;
|
|
|
|
let _e2704: vec4<f32> = temporary3_;
|
|
|
|
let _e2706: vec4<f32> = (_e2702.xyzz * _e2704.wwww);
|
|
|
|
temporary14_.x = _e2706.x;
|
|
|
|
temporary14_.y = _e2706.y;
|
|
|
|
temporary14_.z = _e2706.z;
|
|
|
|
let _e2713: vec4<f32> = temporary15_;
|
|
|
|
let _e2715: vec4<f32> = temporary14_;
|
|
|
|
let _e2717: vec4<f32> = (_e2713.xyzz + _e2715.xyzz);
|
|
|
|
temporary20_.x = _e2717.x;
|
|
|
|
temporary20_.y = _e2717.y;
|
|
|
|
temporary20_.z = _e2717.z;
|
|
|
|
let _e2724: vec4<f32> = temporary20_;
|
|
|
|
let _e2726: vec4<f32> = temporary18_;
|
|
|
|
let _e2728: vec4<f32> = (_e2724.xyzz - _e2726.xyzz);
|
|
|
|
temporary16_.x = _e2728.x;
|
|
|
|
temporary16_.y = _e2728.y;
|
|
|
|
temporary16_.z = _e2728.z;
|
|
|
|
let _e2735: vec4<f32> = temporary16_;
|
|
|
|
let _e2737: vec3<f32> = normalize(_e2735.xyz);
|
|
|
|
temporary19_.x = _e2737.x;
|
|
|
|
temporary19_.y = _e2737.y;
|
|
|
|
temporary19_.z = _e2737.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2744: vec4<f32> = temporary13_;
|
|
|
|
temporary4_.y = _e2744.xxxx.x;
|
|
|
|
let _e2748: vec4<f32> = temporary19_;
|
|
|
|
let _e2749: vec4<f32> = _e2748.xyzz;
|
|
|
|
temporary3_.x = _e2749.x;
|
|
|
|
temporary3_.y = _e2749.y;
|
|
|
|
temporary3_.z = _e2749.z;
|
|
|
|
let _e2756: vec4<f32> = temporary4_;
|
|
|
|
let _e2758: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e2756.yyyy < _e2758.zzzz)).x;
|
|
|
|
let _e2764: vec4<f32> = temporary8_;
|
|
|
|
let _e2768: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2764.zzzz != _e2768.xxxx)) {
|
|
|
|
let _e2772: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e2772.yyyy.x;
|
|
|
|
let _e2776: vec4<f32> = temporary3_;
|
|
|
|
let _e2777: vec4<f32> = _e2776.xyzz;
|
|
|
|
temporary6_.x = _e2777.x;
|
|
|
|
temporary6_.y = _e2777.y;
|
|
|
|
temporary6_.z = _e2777.z;
|
|
|
|
let _e2786: vec4<f32> = constant_registers[8u];
|
|
|
|
let _e2787: vec4<f32> = _e2786.xyzz;
|
|
|
|
temporary7_.x = _e2787.x;
|
|
|
|
temporary7_.y = _e2787.y;
|
|
|
|
temporary7_.z = _e2787.z;
|
|
|
|
let _e2796: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e2796.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e2800: vec4<f32> = temporary2_;
|
|
|
|
let _e2801: vec4<f32> = _e2800.xyzz;
|
|
|
|
temporary15_.x = _e2801.x;
|
|
|
|
temporary15_.y = _e2801.y;
|
|
|
|
temporary15_.z = _e2801.z;
|
|
|
|
let _e2808: vec4<f32> = temporary9_;
|
|
|
|
let _e2809: vec4<f32> = _e2808.xyzz;
|
|
|
|
temporary17_.x = _e2809.x;
|
|
|
|
temporary17_.y = _e2809.y;
|
|
|
|
temporary17_.z = _e2809.z;
|
|
|
|
let _e2818: vec4<f32> = constant_registers[10u];
|
|
|
|
let _e2819: vec4<f32> = _e2818.xyzz;
|
|
|
|
temporary18_.x = _e2819.x;
|
|
|
|
temporary18_.y = _e2819.y;
|
|
|
|
temporary18_.z = _e2819.z;
|
|
|
|
let _e2828: vec4<f32> = constant_registers[12u];
|
|
|
|
temporary2_.w = _e2828.xxxx.x;
|
|
|
|
let _e2832: vec4<f32> = temporary3_;
|
|
|
|
let _e2833: vec4<f32> = _e2832.xyzz;
|
|
|
|
temporary19_.x = _e2833.x;
|
|
|
|
temporary19_.y = _e2833.y;
|
|
|
|
temporary19_.z = _e2833.z;
|
|
|
|
let _e2842: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary13_.x = _e2842.wwww.x;
|
|
|
|
let _e2846: vec4<f32> = temporary15_;
|
|
|
|
let _e2848: vec4<f32> = temporary18_;
|
|
|
|
let _e2850: vec4<f32> = (_e2846.xyzz - _e2848.xyzz);
|
|
|
|
temporary12_.x = _e2850.x;
|
|
|
|
temporary12_.y = _e2850.y;
|
|
|
|
temporary12_.z = _e2850.z;
|
|
|
|
let _e2857: vec4<f32> = temporary12_;
|
|
|
|
let _e2859: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.y = dot(_e2857.xyz, _e2859.xyz);
|
|
|
|
let _e2863: vec4<f32> = temporary13_;
|
|
|
|
let _e2865: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = (_e2863.yyyy * _e2865.yyyy).x;
|
|
|
|
let _e2870: vec4<f32> = temporary12_;
|
|
|
|
let _e2872: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.x = dot(_e2870.xyz, _e2872.xyz);
|
|
|
|
let _e2876: vec4<f32> = temporary3_;
|
|
|
|
let _e2878: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = (_e2876.wwww - _e2878.xxxx).x;
|
|
|
|
let _e2883: vec4<f32> = temporary2_;
|
|
|
|
let _e2885: vec4<f32> = temporary2_;
|
|
|
|
temporary14_.z = (_e2883.wwww * _e2885.wwww).x;
|
|
|
|
let _e2890: vec4<f32> = temporary14_;
|
|
|
|
let _e2892: vec4<f32> = temporary14_;
|
|
|
|
temporary4_.x = (_e2890.yyyy + _e2892.zzzz).x;
|
|
|
|
let _e2897: vec4<f32> = temporary4_;
|
|
|
|
temporary13_.z = _e2897.xxxx.x;
|
|
|
|
let _e2903: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2905: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e2903.xxxx < _e2905.zzzz)).x;
|
|
|
|
let _e2911: vec4<f32> = temporary3_;
|
|
|
|
let _e2915: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2911.wwww != _e2915.xxxx)) {
|
|
|
|
let _e2919: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = sqrt(_e2919.zzzz).x;
|
|
|
|
let _e2924: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.x = -(_e2924.yyyy).x;
|
|
|
|
let _e2929: vec4<f32> = temporary14_;
|
|
|
|
let _e2931: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.y = (_e2929.xxxx - _e2931.zzzz).x;
|
|
|
|
let _e2936: vec4<f32> = temporary14_;
|
|
|
|
temporary3_.w = _e2936.yyyy.x;
|
|
|
|
let _e2942: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e2944: vec4<f32> = temporary3_;
|
|
|
|
temporary14_.x = vec4<f32>((_e2942.xxxx < _e2944.wwww)).x;
|
|
|
|
let _e2950: vec4<f32> = temporary14_;
|
|
|
|
let _e2954: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e2950.xxxx != _e2954.xxxx)) {
|
|
|
|
let _e2958: vec4<f32> = temporary3_;
|
|
|
|
temporary13_.x = _e2958.wwww.x;
|
|
|
|
let _e2962: vec4<f32> = temporary17_;
|
|
|
|
let _e2964: vec4<f32> = temporary3_;
|
|
|
|
let _e2966: vec4<f32> = (_e2962.xyzz * _e2964.wwww);
|
|
|
|
temporary14_.x = _e2966.x;
|
|
|
|
temporary14_.y = _e2966.y;
|
|
|
|
temporary14_.z = _e2966.z;
|
|
|
|
let _e2973: vec4<f32> = temporary15_;
|
|
|
|
let _e2975: vec4<f32> = temporary14_;
|
|
|
|
let _e2977: vec4<f32> = (_e2973.xyzz + _e2975.xyzz);
|
|
|
|
temporary20_.x = _e2977.x;
|
|
|
|
temporary20_.y = _e2977.y;
|
|
|
|
temporary20_.z = _e2977.z;
|
|
|
|
let _e2984: vec4<f32> = temporary20_;
|
|
|
|
let _e2986: vec4<f32> = temporary18_;
|
|
|
|
let _e2988: vec4<f32> = (_e2984.xyzz - _e2986.xyzz);
|
|
|
|
temporary16_.x = _e2988.x;
|
|
|
|
temporary16_.y = _e2988.y;
|
|
|
|
temporary16_.z = _e2988.z;
|
|
|
|
let _e2995: vec4<f32> = temporary16_;
|
|
|
|
let _e2997: vec3<f32> = normalize(_e2995.xyz);
|
|
|
|
temporary19_.x = _e2997.x;
|
|
|
|
temporary19_.y = _e2997.y;
|
|
|
|
temporary19_.z = _e2997.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3004: vec4<f32> = temporary13_;
|
|
|
|
temporary4_.y = _e3004.xxxx.x;
|
|
|
|
let _e3008: vec4<f32> = temporary19_;
|
|
|
|
let _e3009: vec4<f32> = _e3008.xyzz;
|
|
|
|
temporary3_.x = _e3009.x;
|
|
|
|
temporary3_.y = _e3009.y;
|
|
|
|
temporary3_.z = _e3009.z;
|
|
|
|
let _e3016: vec4<f32> = temporary4_;
|
|
|
|
let _e3018: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e3016.yyyy < _e3018.zzzz)).x;
|
|
|
|
let _e3024: vec4<f32> = temporary8_;
|
|
|
|
let _e3028: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3024.zzzz != _e3028.xxxx)) {
|
|
|
|
let _e3032: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e3032.yyyy.x;
|
|
|
|
let _e3036: vec4<f32> = temporary3_;
|
|
|
|
let _e3037: vec4<f32> = _e3036.xyzz;
|
|
|
|
temporary6_.x = _e3037.x;
|
|
|
|
temporary6_.y = _e3037.y;
|
|
|
|
temporary6_.z = _e3037.z;
|
|
|
|
let _e3046: vec4<f32> = constant_registers[11u];
|
|
|
|
let _e3047: vec4<f32> = _e3046.xyzz;
|
|
|
|
temporary7_.x = _e3047.x;
|
|
|
|
temporary7_.y = _e3047.y;
|
|
|
|
temporary7_.z = _e3047.z;
|
|
|
|
let _e3056: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e3056.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3060: vec4<f32> = temporary11_;
|
|
|
|
let _e3064: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary11_.y = (_e3060.yyyy + _e3064.yyyy).x;
|
|
|
|
let _e3069: vec4<f32> = temporary1_;
|
|
|
|
let _e3073: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.z = vec4<f32>((_e3069.zzzz == _e3073.xxxx)).x;
|
|
|
|
let _e3079: vec4<f32> = temporary8_;
|
|
|
|
let _e3083: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3079.zzzz != _e3083.xxxx)) {
|
|
|
|
let _e3089: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3090: vec4<f32> = _e3089.xyyy;
|
|
|
|
temporary11_.x = _e3090.x;
|
|
|
|
temporary11_.z = _e3090.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
} else {
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3095: vec4<f32> = temporary9_;
|
|
|
|
let _e3097: vec4<f32> = temporary4_;
|
|
|
|
let _e3099: vec4<f32> = (_e3095.xyzz * _e3097.zzzz);
|
|
|
|
temporary15_.x = _e3099.x;
|
|
|
|
temporary15_.y = _e3099.y;
|
|
|
|
temporary15_.z = _e3099.z;
|
|
|
|
let _e3106: vec4<f32> = temporary2_;
|
|
|
|
let _e3108: vec4<f32> = temporary15_;
|
|
|
|
let _e3110: vec4<f32> = (_e3106.xyzz + _e3108.xyzz);
|
|
|
|
temporary2_.x = _e3110.x;
|
|
|
|
temporary2_.y = _e3110.y;
|
|
|
|
temporary2_.z = _e3110.z;
|
|
|
|
let _e3117: vec4<f32> = temporary9_;
|
|
|
|
let _e3119: vec4<f32> = temporary6_;
|
|
|
|
temporary8_.z = dot(_e3117.xyz, _e3119.xyz);
|
|
|
|
let _e3123: vec4<f32> = temporary8_;
|
|
|
|
let _e3127: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary2_.w = (_e3123.zzzz * _e3127.xxxx).x;
|
|
|
|
let _e3132: vec4<f32> = temporary2_;
|
|
|
|
let _e3134: vec4<f32> = temporary6_;
|
|
|
|
let _e3136: vec4<f32> = (_e3132.wwww * _e3134.xyzz);
|
|
|
|
temporary15_.x = _e3136.x;
|
|
|
|
temporary15_.y = _e3136.y;
|
|
|
|
temporary15_.z = _e3136.z;
|
|
|
|
let _e3143: vec4<f32> = temporary9_;
|
|
|
|
let _e3145: vec4<f32> = temporary15_;
|
|
|
|
let _e3147: vec4<f32> = (_e3143.xyzz - _e3145.xyzz);
|
|
|
|
temporary9_.x = _e3147.x;
|
|
|
|
temporary9_.y = _e3147.y;
|
|
|
|
temporary9_.z = _e3147.z;
|
|
|
|
let _e3154: vec4<f32> = temporary9_;
|
|
|
|
let _e3158: vec4<f32> = constant_registers[18u];
|
|
|
|
let _e3160: vec4<f32> = (_e3154.xyzz * _e3158.yyyy);
|
|
|
|
temporary15_.x = _e3160.x;
|
|
|
|
temporary15_.y = _e3160.y;
|
|
|
|
temporary15_.z = _e3160.z;
|
|
|
|
let _e3167: vec4<f32> = temporary2_;
|
|
|
|
let _e3169: vec4<f32> = temporary15_;
|
|
|
|
let _e3171: vec4<f32> = (_e3167.xyzz + _e3169.xyzz);
|
|
|
|
temporary2_.x = _e3171.x;
|
|
|
|
temporary2_.y = _e3171.y;
|
|
|
|
temporary2_.z = _e3171.z;
|
|
|
|
let _e3180: vec4<f32> = constant_registers[15u];
|
|
|
|
let _e3182: vec4<f32> = temporary2_;
|
|
|
|
let _e3184: vec4<f32> = (_e3180.xyzz - _e3182.xyzz);
|
|
|
|
temporary5_.x = _e3184.x;
|
|
|
|
temporary5_.y = _e3184.y;
|
|
|
|
temporary5_.z = _e3184.z;
|
|
|
|
let _e3191: vec4<f32> = temporary5_;
|
|
|
|
let _e3193: vec3<f32> = normalize(_e3191.xyz);
|
|
|
|
temporary10_.x = _e3193.x;
|
|
|
|
temporary10_.y = _e3193.y;
|
|
|
|
temporary10_.z = _e3193.z;
|
|
|
|
let _e3200: vec4<f32> = temporary5_;
|
|
|
|
let _e3202: vec4<f32> = temporary5_;
|
|
|
|
temporary8_.z = dot(_e3200.xyz, _e3202.xyz);
|
|
|
|
let _e3206: vec4<f32> = temporary8_;
|
|
|
|
temporary1_.y = sqrt(_e3206.zzzz).x;
|
|
|
|
let _e3211: vec4<f32> = temporary6_;
|
|
|
|
let _e3213: vec4<f32> = temporary10_;
|
|
|
|
temporary8_.z = dot(_e3211.xyz, _e3213.xyz);
|
|
|
|
let _e3217: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = saturate(_e3217.zzzz).x;
|
|
|
|
let _e3222: vec4<f32> = temporary1_;
|
|
|
|
let _e3224: vec4<f32> = temporary1_;
|
|
|
|
temporary15_.x = (_e3222.yyyy * _e3224.yyyy).x;
|
|
|
|
let _e3229: vec4<f32> = temporary15_;
|
|
|
|
let _e3233: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary15_.y = (_e3229.xxxx * _e3233.zzzz).x;
|
|
|
|
let _e3240: vec4<f32> = constant_registers[18u];
|
|
|
|
let _e3242: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.z = (_e3240.wwww + _e3242.yyyy).x;
|
|
|
|
let _e3247: vec4<f32> = temporary2_;
|
|
|
|
let _e3249: vec4<f32> = temporary15_;
|
|
|
|
temporary1_.x = (_e3247.wwww / _e3249.zzzz).x;
|
|
|
|
let _e3254: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.x = _e3254.xxxx.x;
|
|
|
|
let _e3260: vec4<f32> = constant_registers[6u];
|
|
|
|
temporary2_.w = _e3260.xxxx.x;
|
|
|
|
let _e3266: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary19_.x = _e3266.wwww.x;
|
|
|
|
let _e3270: vec4<f32> = temporary2_;
|
|
|
|
let _e3274: vec4<f32> = constant_registers[4u];
|
|
|
|
let _e3276: vec4<f32> = (_e3270.xyzz - _e3274.xyzz);
|
|
|
|
temporary13_.x = _e3276.x;
|
|
|
|
temporary13_.y = _e3276.y;
|
|
|
|
temporary13_.z = _e3276.z;
|
|
|
|
let _e3283: vec4<f32> = temporary13_;
|
|
|
|
let _e3285: vec4<f32> = temporary10_;
|
|
|
|
temporary19_.y = dot(_e3283.xyz, _e3285.xyz);
|
|
|
|
let _e3289: vec4<f32> = temporary19_;
|
|
|
|
let _e3291: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e3289.yyyy * _e3291.yyyy).x;
|
|
|
|
let _e3296: vec4<f32> = temporary13_;
|
|
|
|
let _e3298: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = dot(_e3296.xyz, _e3298.xyz);
|
|
|
|
let _e3302: vec4<f32> = temporary1_;
|
|
|
|
let _e3304: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e3302.wwww - _e3304.xxxx).x;
|
|
|
|
let _e3309: vec4<f32> = temporary2_;
|
|
|
|
let _e3311: vec4<f32> = temporary2_;
|
|
|
|
temporary12_.z = (_e3309.wwww * _e3311.wwww).x;
|
|
|
|
let _e3316: vec4<f32> = temporary12_;
|
|
|
|
let _e3318: vec4<f32> = temporary12_;
|
|
|
|
temporary19_.z = (_e3316.yyyy + _e3318.zzzz).x;
|
|
|
|
let _e3325: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3327: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = vec4<f32>((_e3325.xxxx < _e3327.zzzz)).x;
|
|
|
|
let _e3333: vec4<f32> = temporary1_;
|
|
|
|
let _e3337: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3333.wwww != _e3337.xxxx)) {
|
|
|
|
let _e3341: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = sqrt(_e3341.zzzz).x;
|
|
|
|
let _e3346: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.x = -(_e3346.yyyy).x;
|
|
|
|
let _e3351: vec4<f32> = temporary12_;
|
|
|
|
let _e3353: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e3351.xxxx - _e3353.zzzz).x;
|
|
|
|
let _e3360: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3362: vec4<f32> = temporary1_;
|
|
|
|
temporary12_.x = vec4<f32>((_e3360.xxxx < _e3362.wwww)).x;
|
|
|
|
let _e3368: vec4<f32> = temporary12_;
|
|
|
|
let _e3372: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3368.xxxx != _e3372.xxxx)) {
|
|
|
|
let _e3376: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = _e3376.wwww.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3380: vec4<f32> = temporary19_;
|
|
|
|
let _e3382: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.z = vec4<f32>((_e3380.xxxx < _e3382.yyyy)).x;
|
|
|
|
let _e3388: vec4<f32> = temporary8_;
|
|
|
|
let _e3392: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3388.zzzz != _e3392.xxxx)) {
|
|
|
|
let _e3398: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e3398.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3404: vec4<f32> = constant_registers[9u];
|
|
|
|
temporary2_.w = _e3404.xxxx.x;
|
|
|
|
let _e3410: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary19_.x = _e3410.wwww.x;
|
|
|
|
let _e3414: vec4<f32> = temporary2_;
|
|
|
|
let _e3418: vec4<f32> = constant_registers[7u];
|
|
|
|
let _e3420: vec4<f32> = (_e3414.xyzz - _e3418.xyzz);
|
|
|
|
temporary13_.x = _e3420.x;
|
|
|
|
temporary13_.y = _e3420.y;
|
|
|
|
temporary13_.z = _e3420.z;
|
|
|
|
let _e3427: vec4<f32> = temporary13_;
|
|
|
|
let _e3429: vec4<f32> = temporary10_;
|
|
|
|
temporary19_.y = dot(_e3427.xyz, _e3429.xyz);
|
|
|
|
let _e3433: vec4<f32> = temporary19_;
|
|
|
|
let _e3435: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e3433.yyyy * _e3435.yyyy).x;
|
|
|
|
let _e3440: vec4<f32> = temporary13_;
|
|
|
|
let _e3442: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = dot(_e3440.xyz, _e3442.xyz);
|
|
|
|
let _e3446: vec4<f32> = temporary1_;
|
|
|
|
let _e3448: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e3446.wwww - _e3448.xxxx).x;
|
|
|
|
let _e3453: vec4<f32> = temporary2_;
|
|
|
|
let _e3455: vec4<f32> = temporary2_;
|
|
|
|
temporary12_.z = (_e3453.wwww * _e3455.wwww).x;
|
|
|
|
let _e3460: vec4<f32> = temporary12_;
|
|
|
|
let _e3462: vec4<f32> = temporary12_;
|
|
|
|
temporary19_.z = (_e3460.yyyy + _e3462.zzzz).x;
|
|
|
|
let _e3469: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3471: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = vec4<f32>((_e3469.xxxx < _e3471.zzzz)).x;
|
|
|
|
let _e3477: vec4<f32> = temporary1_;
|
|
|
|
let _e3481: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3477.wwww != _e3481.xxxx)) {
|
|
|
|
let _e3485: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = sqrt(_e3485.zzzz).x;
|
|
|
|
let _e3490: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.x = -(_e3490.yyyy).x;
|
|
|
|
let _e3495: vec4<f32> = temporary12_;
|
|
|
|
let _e3497: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e3495.xxxx - _e3497.zzzz).x;
|
|
|
|
let _e3504: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3506: vec4<f32> = temporary1_;
|
|
|
|
temporary12_.x = vec4<f32>((_e3504.xxxx < _e3506.wwww)).x;
|
|
|
|
let _e3512: vec4<f32> = temporary12_;
|
|
|
|
let _e3516: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3512.xxxx != _e3516.xxxx)) {
|
|
|
|
let _e3520: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = _e3520.wwww.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3524: vec4<f32> = temporary19_;
|
|
|
|
let _e3526: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.z = vec4<f32>((_e3524.xxxx < _e3526.yyyy)).x;
|
|
|
|
let _e3532: vec4<f32> = temporary8_;
|
|
|
|
let _e3536: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3532.zzzz != _e3536.xxxx)) {
|
|
|
|
let _e3542: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e3542.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3546: vec4<f32> = temporary2_;
|
|
|
|
let _e3547: vec4<f32> = _e3546.xyzz;
|
|
|
|
temporary15_.x = _e3547.x;
|
|
|
|
temporary15_.y = _e3547.y;
|
|
|
|
temporary15_.z = _e3547.z;
|
|
|
|
let _e3554: vec4<f32> = temporary10_;
|
|
|
|
let _e3555: vec4<f32> = _e3554.xyzz;
|
|
|
|
temporary17_.x = _e3555.x;
|
|
|
|
temporary17_.y = _e3555.y;
|
|
|
|
temporary17_.z = _e3555.z;
|
|
|
|
let _e3564: vec4<f32> = constant_registers[10u];
|
|
|
|
let _e3565: vec4<f32> = _e3564.xyzz;
|
|
|
|
temporary18_.x = _e3565.x;
|
|
|
|
temporary18_.y = _e3565.y;
|
|
|
|
temporary18_.z = _e3565.z;
|
|
|
|
let _e3574: vec4<f32> = constant_registers[12u];
|
|
|
|
temporary2_.w = _e3574.xxxx.x;
|
|
|
|
let _e3580: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary19_.x = _e3580.wwww.x;
|
|
|
|
let _e3584: vec4<f32> = temporary15_;
|
|
|
|
let _e3586: vec4<f32> = temporary18_;
|
|
|
|
let _e3588: vec4<f32> = (_e3584.xyzz - _e3586.xyzz);
|
|
|
|
temporary13_.x = _e3588.x;
|
|
|
|
temporary13_.y = _e3588.y;
|
|
|
|
temporary13_.z = _e3588.z;
|
|
|
|
let _e3595: vec4<f32> = temporary13_;
|
|
|
|
let _e3597: vec4<f32> = temporary17_;
|
|
|
|
temporary19_.y = dot(_e3595.xyz, _e3597.xyz);
|
|
|
|
let _e3601: vec4<f32> = temporary19_;
|
|
|
|
let _e3603: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e3601.yyyy * _e3603.yyyy).x;
|
|
|
|
let _e3608: vec4<f32> = temporary13_;
|
|
|
|
let _e3610: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = dot(_e3608.xyz, _e3610.xyz);
|
|
|
|
let _e3614: vec4<f32> = temporary1_;
|
|
|
|
let _e3616: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e3614.wwww - _e3616.xxxx).x;
|
|
|
|
let _e3621: vec4<f32> = temporary2_;
|
|
|
|
let _e3623: vec4<f32> = temporary2_;
|
|
|
|
temporary12_.z = (_e3621.wwww * _e3623.wwww).x;
|
|
|
|
let _e3628: vec4<f32> = temporary12_;
|
|
|
|
let _e3630: vec4<f32> = temporary12_;
|
|
|
|
temporary19_.z = (_e3628.yyyy + _e3630.zzzz).x;
|
|
|
|
let _e3637: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3639: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = vec4<f32>((_e3637.xxxx < _e3639.zzzz)).x;
|
|
|
|
let _e3645: vec4<f32> = temporary1_;
|
|
|
|
let _e3649: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3645.wwww != _e3649.xxxx)) {
|
|
|
|
let _e3653: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = sqrt(_e3653.zzzz).x;
|
|
|
|
let _e3658: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.x = -(_e3658.yyyy).x;
|
|
|
|
let _e3663: vec4<f32> = temporary12_;
|
|
|
|
let _e3665: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.y = (_e3663.xxxx - _e3665.zzzz).x;
|
|
|
|
let _e3670: vec4<f32> = temporary12_;
|
|
|
|
temporary1_.w = _e3670.yyyy.x;
|
|
|
|
let _e3676: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3678: vec4<f32> = temporary1_;
|
|
|
|
temporary12_.x = vec4<f32>((_e3676.xxxx < _e3678.wwww)).x;
|
|
|
|
let _e3684: vec4<f32> = temporary12_;
|
|
|
|
let _e3688: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3684.xxxx != _e3688.xxxx)) {
|
|
|
|
let _e3692: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = _e3692.wwww.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3696: vec4<f32> = temporary19_;
|
|
|
|
temporary4_.y = _e3696.xxxx.x;
|
|
|
|
let _e3700: vec4<f32> = temporary4_;
|
|
|
|
let _e3702: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.z = vec4<f32>((_e3700.yyyy < _e3702.yyyy)).x;
|
|
|
|
let _e3708: vec4<f32> = temporary8_;
|
|
|
|
let _e3712: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3708.zzzz != _e3712.xxxx)) {
|
|
|
|
let _e3718: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e3718.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3722: vec4<f32> = temporary6_;
|
|
|
|
temporary8_.z = saturate(_e3722.yyyy).x;
|
|
|
|
let _e3727: vec4<f32> = temporary8_;
|
|
|
|
let _e3731: vec4<f32> = constant_registers[19u];
|
|
|
|
temporary2_.w = (_e3727.zzzz * _e3731.xxxx).x;
|
|
|
|
let _e3736: vec4<f32> = temporary8_;
|
|
|
|
let _e3738: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.x = (_e3736.xxxx + _e3738.wwww).x;
|
|
|
|
let _e3743: vec4<f32> = temporary8_;
|
|
|
|
let _e3747: vec4<f32> = constant_registers[19u];
|
|
|
|
temporary8_.z = (_e3743.xxxx * _e3747.yyyy).x;
|
|
|
|
let _e3754: vec4<f32> = constant_registers[19u];
|
|
|
|
let _e3756: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = (_e3754.zzzz + _e3756.zzzz).x;
|
|
|
|
let _e3761: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.y = _e3761.wwww.x;
|
|
|
|
let _e3765: vec4<f32> = temporary1_;
|
|
|
|
let _e3769: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.z = vec4<f32>((_e3765.zzzz == _e3769.yyyy)).x;
|
|
|
|
let _e3775: vec4<f32> = temporary8_;
|
|
|
|
let _e3779: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3775.zzzz != _e3779.xxxx)) {
|
|
|
|
let _e3783: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.z = fract(_e3783.xxxx).x;
|
|
|
|
let _e3788: vec4<f32> = temporary2_;
|
|
|
|
let _e3790: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = (_e3788.xxxx - _e3790.zzzz).x;
|
|
|
|
let _e3795: vec4<f32> = temporary2_;
|
|
|
|
temporary15_.x = fract(_e3795.zzzz).x;
|
|
|
|
let _e3800: vec4<f32> = temporary2_;
|
|
|
|
let _e3802: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.y = (_e3800.zzzz - _e3802.xxxx).x;
|
|
|
|
let _e3807: vec4<f32> = temporary2_;
|
|
|
|
let _e3809: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.z = (_e3807.wwww + _e3809.yyyy).x;
|
|
|
|
let _e3814: vec4<f32> = temporary15_;
|
|
|
|
let _e3818: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.x = (_e3814.zzzz / _e3818.xxxx).x;
|
|
|
|
let _e3823: vec4<f32> = temporary1_;
|
|
|
|
temporary17_.x = fract(_e3823.xxxx).x;
|
|
|
|
let _e3828: vec4<f32> = temporary17_;
|
|
|
|
let _e3832: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary17_.y = (_e3828.xxxx * _e3832.xxxx).x;
|
|
|
|
let _e3837: vec4<f32> = temporary17_;
|
|
|
|
let _e3841: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary17_.z = vec4<f32>((_e3837.yyyy == _e3841.yyyy)).x;
|
|
|
|
let _e3847: vec4<f32> = temporary17_;
|
|
|
|
let _e3851: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3847.zzzz != _e3851.xxxx)) {
|
|
|
|
let _e3857: vec4<f32> = constant_registers[13u];
|
|
|
|
let _e3859: vec4<f32> = temporary8_;
|
|
|
|
let _e3861: vec4<f32> = (_e3857.xyzz * _e3859.yyyy);
|
|
|
|
temporary15_.x = _e3861.x;
|
|
|
|
temporary15_.y = _e3861.y;
|
|
|
|
temporary15_.z = _e3861.z;
|
|
|
|
let _e3868: vec4<f32> = temporary0_;
|
|
|
|
let _e3870: vec4<f32> = temporary15_;
|
|
|
|
let _e3872: vec4<f32> = (_e3868.xyzz + _e3870.xyzz);
|
|
|
|
temporary0_.x = _e3872.x;
|
|
|
|
temporary0_.y = _e3872.y;
|
|
|
|
temporary0_.z = _e3872.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
} else {
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3881: vec4<f32> = constant_registers[14u];
|
|
|
|
let _e3883: vec4<f32> = temporary8_;
|
|
|
|
let _e3885: vec4<f32> = (_e3881.xyzz * _e3883.yyyy);
|
|
|
|
temporary15_.x = _e3885.x;
|
|
|
|
temporary15_.y = _e3885.y;
|
|
|
|
temporary15_.z = _e3885.z;
|
|
|
|
let _e3892: vec4<f32> = temporary0_;
|
|
|
|
let _e3894: vec4<f32> = temporary15_;
|
|
|
|
let _e3896: vec4<f32> = (_e3892.xyzz + _e3894.xyzz);
|
|
|
|
temporary0_.x = _e3896.x;
|
|
|
|
temporary0_.y = _e3896.y;
|
|
|
|
temporary0_.z = _e3896.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3903: vec4<f32> = temporary1_;
|
|
|
|
let _e3907: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary8_.z = vec4<f32>((_e3903.zzzz == _e3907.xxxx)).x;
|
|
|
|
let _e3913: vec4<f32> = temporary8_;
|
|
|
|
let _e3917: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3913.zzzz != _e3917.xxxx)) {
|
|
|
|
let _e3921: vec4<f32> = temporary7_;
|
|
|
|
let _e3923: vec4<f32> = temporary8_;
|
|
|
|
let _e3925: vec4<f32> = (_e3921.xyzz * _e3923.yyyy);
|
|
|
|
temporary15_.x = _e3925.x;
|
|
|
|
temporary15_.y = _e3925.y;
|
|
|
|
temporary15_.z = _e3925.z;
|
|
|
|
let _e3932: vec4<f32> = temporary0_;
|
|
|
|
let _e3934: vec4<f32> = temporary15_;
|
|
|
|
let _e3936: vec4<f32> = (_e3932.xyzz + _e3934.xyzz);
|
|
|
|
temporary0_.x = _e3936.x;
|
|
|
|
temporary0_.y = _e3936.y;
|
|
|
|
temporary0_.z = _e3936.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3945: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary11_.x = _e3945.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e3949: vec4<f32> = temporary11_;
|
|
|
|
let _e3953: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e3949.xxxx != _e3953.xxxx)) {
|
|
|
|
let _e3959: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = _e3959.xxxx.x;
|
|
|
|
let _e3965: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary4_.z = _e3965.wwww.x;
|
|
|
|
let _e3971: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3972: vec4<f32> = _e3971.xyxx;
|
|
|
|
temporary3_.x = _e3972.x;
|
|
|
|
temporary3_.y = _e3972.y;
|
|
|
|
temporary3_.z = _e3972.z;
|
|
|
|
let _e3979: vec4<f32> = temporary3_;
|
|
|
|
let _e3980: vec4<f32> = _e3979.xyzz;
|
|
|
|
temporary12_.x = _e3980.x;
|
|
|
|
temporary12_.y = _e3980.y;
|
|
|
|
temporary12_.z = _e3980.z;
|
|
|
|
let _e3989: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary2_.w = _e3989.wwww.x;
|
|
|
|
let _e3993: vec4<f32> = temporary2_;
|
|
|
|
let _e3997: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e3999: vec4<f32> = (_e3993.xyzz - _e3997.xxxx);
|
|
|
|
temporary20_.x = _e3999.x;
|
|
|
|
temporary20_.y = _e3999.y;
|
|
|
|
temporary20_.z = _e3999.z;
|
|
|
|
let _e4006: vec4<f32> = temporary20_;
|
|
|
|
let _e4008: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.y = dot(_e4006.xyz, _e4008.xyz);
|
|
|
|
let _e4012: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.z = -(_e4012.yyyy).x;
|
|
|
|
let _e4017: vec4<f32> = temporary9_;
|
|
|
|
let _e4019: vec4<f32> = temporary12_;
|
|
|
|
temporary4_.x = dot(_e4017.xyz, _e4019.xyz);
|
|
|
|
let _e4023: vec4<f32> = temporary14_;
|
|
|
|
let _e4025: vec4<f32> = temporary4_;
|
|
|
|
temporary16_.x = (_e4023.zzzz / _e4025.xxxx).x;
|
|
|
|
let _e4030: vec4<f32> = temporary16_;
|
|
|
|
temporary14_.x = _e4030.xxxx.x;
|
|
|
|
let _e4036: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4038: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = vec4<f32>((_e4036.xxxx < _e4038.xxxx)).x;
|
|
|
|
let _e4044: vec4<f32> = temporary14_;
|
|
|
|
let _e4048: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4044.yyyy != _e4048.xxxx)) {
|
|
|
|
let _e4052: vec4<f32> = temporary14_;
|
|
|
|
temporary2_.w = _e4052.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4056: vec4<f32> = temporary2_;
|
|
|
|
temporary4_.y = _e4056.wwww.x;
|
|
|
|
let _e4060: vec4<f32> = temporary4_;
|
|
|
|
let _e4062: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e4060.yyyy < _e4062.zzzz)).x;
|
|
|
|
let _e4068: vec4<f32> = temporary8_;
|
|
|
|
let _e4072: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4068.zzzz != _e4072.xxxx)) {
|
|
|
|
let _e4076: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e4076.yyyy.x;
|
|
|
|
let _e4080: vec4<f32> = temporary3_;
|
|
|
|
let _e4081: vec4<f32> = _e4080.xyzz;
|
|
|
|
temporary6_.x = _e4081.x;
|
|
|
|
temporary6_.y = _e4081.y;
|
|
|
|
temporary6_.z = _e4081.z;
|
|
|
|
let _e4090: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary1_.z = _e4090.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4094: vec4<f32> = temporary2_;
|
|
|
|
let _e4095: vec4<f32> = _e4094.xyzz;
|
|
|
|
temporary15_.x = _e4095.x;
|
|
|
|
temporary15_.y = _e4095.y;
|
|
|
|
temporary15_.z = _e4095.z;
|
|
|
|
let _e4102: vec4<f32> = temporary9_;
|
|
|
|
let _e4103: vec4<f32> = _e4102.xyzz;
|
|
|
|
temporary17_.x = _e4103.x;
|
|
|
|
temporary17_.y = _e4103.y;
|
|
|
|
temporary17_.z = _e4103.z;
|
|
|
|
let _e4112: vec4<f32> = constant_registers[4u];
|
|
|
|
let _e4113: vec4<f32> = _e4112.xyzz;
|
|
|
|
temporary18_.x = _e4113.x;
|
|
|
|
temporary18_.y = _e4113.y;
|
|
|
|
temporary18_.z = _e4113.z;
|
|
|
|
let _e4122: vec4<f32> = constant_registers[6u];
|
|
|
|
temporary2_.w = _e4122.xxxx.x;
|
|
|
|
let _e4126: vec4<f32> = temporary3_;
|
|
|
|
let _e4127: vec4<f32> = _e4126.xyzz;
|
|
|
|
temporary19_.x = _e4127.x;
|
|
|
|
temporary19_.y = _e4127.y;
|
|
|
|
temporary19_.z = _e4127.z;
|
|
|
|
let _e4136: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary13_.x = _e4136.wwww.x;
|
|
|
|
let _e4140: vec4<f32> = temporary15_;
|
|
|
|
let _e4142: vec4<f32> = temporary18_;
|
|
|
|
let _e4144: vec4<f32> = (_e4140.xyzz - _e4142.xyzz);
|
|
|
|
temporary12_.x = _e4144.x;
|
|
|
|
temporary12_.y = _e4144.y;
|
|
|
|
temporary12_.z = _e4144.z;
|
|
|
|
let _e4151: vec4<f32> = temporary12_;
|
|
|
|
let _e4153: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.y = dot(_e4151.xyz, _e4153.xyz);
|
|
|
|
let _e4157: vec4<f32> = temporary13_;
|
|
|
|
let _e4159: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = (_e4157.yyyy * _e4159.yyyy).x;
|
|
|
|
let _e4164: vec4<f32> = temporary12_;
|
|
|
|
let _e4166: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.x = dot(_e4164.xyz, _e4166.xyz);
|
|
|
|
let _e4170: vec4<f32> = temporary3_;
|
|
|
|
let _e4172: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = (_e4170.wwww - _e4172.xxxx).x;
|
|
|
|
let _e4177: vec4<f32> = temporary2_;
|
|
|
|
let _e4179: vec4<f32> = temporary2_;
|
|
|
|
temporary14_.z = (_e4177.wwww * _e4179.wwww).x;
|
|
|
|
let _e4184: vec4<f32> = temporary14_;
|
|
|
|
let _e4186: vec4<f32> = temporary14_;
|
|
|
|
temporary13_.z = (_e4184.yyyy + _e4186.zzzz).x;
|
|
|
|
let _e4193: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4195: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e4193.xxxx < _e4195.zzzz)).x;
|
|
|
|
let _e4201: vec4<f32> = temporary3_;
|
|
|
|
let _e4205: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4201.wwww != _e4205.xxxx)) {
|
|
|
|
let _e4209: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = sqrt(_e4209.zzzz).x;
|
|
|
|
let _e4214: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.x = -(_e4214.yyyy).x;
|
|
|
|
let _e4219: vec4<f32> = temporary14_;
|
|
|
|
let _e4221: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.y = (_e4219.xxxx - _e4221.zzzz).x;
|
|
|
|
let _e4226: vec4<f32> = temporary14_;
|
|
|
|
temporary3_.w = _e4226.yyyy.x;
|
|
|
|
let _e4232: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4234: vec4<f32> = temporary3_;
|
|
|
|
temporary14_.x = vec4<f32>((_e4232.xxxx < _e4234.wwww)).x;
|
|
|
|
let _e4240: vec4<f32> = temporary14_;
|
|
|
|
let _e4244: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4240.xxxx != _e4244.xxxx)) {
|
|
|
|
let _e4248: vec4<f32> = temporary3_;
|
|
|
|
temporary13_.x = _e4248.wwww.x;
|
|
|
|
let _e4252: vec4<f32> = temporary17_;
|
|
|
|
let _e4254: vec4<f32> = temporary3_;
|
|
|
|
let _e4256: vec4<f32> = (_e4252.xyzz * _e4254.wwww);
|
|
|
|
temporary14_.x = _e4256.x;
|
|
|
|
temporary14_.y = _e4256.y;
|
|
|
|
temporary14_.z = _e4256.z;
|
|
|
|
let _e4263: vec4<f32> = temporary15_;
|
|
|
|
let _e4265: vec4<f32> = temporary14_;
|
|
|
|
let _e4267: vec4<f32> = (_e4263.xyzz + _e4265.xyzz);
|
|
|
|
temporary20_.x = _e4267.x;
|
|
|
|
temporary20_.y = _e4267.y;
|
|
|
|
temporary20_.z = _e4267.z;
|
|
|
|
let _e4274: vec4<f32> = temporary20_;
|
|
|
|
let _e4276: vec4<f32> = temporary18_;
|
|
|
|
let _e4278: vec4<f32> = (_e4274.xyzz - _e4276.xyzz);
|
|
|
|
temporary16_.x = _e4278.x;
|
|
|
|
temporary16_.y = _e4278.y;
|
|
|
|
temporary16_.z = _e4278.z;
|
|
|
|
let _e4285: vec4<f32> = temporary16_;
|
|
|
|
let _e4287: vec3<f32> = normalize(_e4285.xyz);
|
|
|
|
temporary19_.x = _e4287.x;
|
|
|
|
temporary19_.y = _e4287.y;
|
|
|
|
temporary19_.z = _e4287.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4294: vec4<f32> = temporary13_;
|
|
|
|
temporary4_.y = _e4294.xxxx.x;
|
|
|
|
let _e4298: vec4<f32> = temporary19_;
|
|
|
|
let _e4299: vec4<f32> = _e4298.xyzz;
|
|
|
|
temporary3_.x = _e4299.x;
|
|
|
|
temporary3_.y = _e4299.y;
|
|
|
|
temporary3_.z = _e4299.z;
|
|
|
|
let _e4306: vec4<f32> = temporary4_;
|
|
|
|
let _e4308: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e4306.yyyy < _e4308.zzzz)).x;
|
|
|
|
let _e4314: vec4<f32> = temporary8_;
|
|
|
|
let _e4318: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4314.zzzz != _e4318.xxxx)) {
|
|
|
|
let _e4322: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e4322.yyyy.x;
|
|
|
|
let _e4326: vec4<f32> = temporary3_;
|
|
|
|
let _e4327: vec4<f32> = _e4326.xyzz;
|
|
|
|
temporary6_.x = _e4327.x;
|
|
|
|
temporary6_.y = _e4327.y;
|
|
|
|
temporary6_.z = _e4327.z;
|
|
|
|
let _e4336: vec4<f32> = constant_registers[5u];
|
|
|
|
let _e4337: vec4<f32> = _e4336.xyzz;
|
|
|
|
temporary7_.x = _e4337.x;
|
|
|
|
temporary7_.y = _e4337.y;
|
|
|
|
temporary7_.z = _e4337.z;
|
|
|
|
let _e4346: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e4346.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4350: vec4<f32> = temporary2_;
|
|
|
|
let _e4351: vec4<f32> = _e4350.xyzz;
|
|
|
|
temporary15_.x = _e4351.x;
|
|
|
|
temporary15_.y = _e4351.y;
|
|
|
|
temporary15_.z = _e4351.z;
|
|
|
|
let _e4358: vec4<f32> = temporary9_;
|
|
|
|
let _e4359: vec4<f32> = _e4358.xyzz;
|
|
|
|
temporary17_.x = _e4359.x;
|
|
|
|
temporary17_.y = _e4359.y;
|
|
|
|
temporary17_.z = _e4359.z;
|
|
|
|
let _e4368: vec4<f32> = constant_registers[7u];
|
|
|
|
let _e4369: vec4<f32> = _e4368.xyzz;
|
|
|
|
temporary18_.x = _e4369.x;
|
|
|
|
temporary18_.y = _e4369.y;
|
|
|
|
temporary18_.z = _e4369.z;
|
|
|
|
let _e4378: vec4<f32> = constant_registers[9u];
|
|
|
|
temporary2_.w = _e4378.xxxx.x;
|
|
|
|
let _e4382: vec4<f32> = temporary3_;
|
|
|
|
let _e4383: vec4<f32> = _e4382.xyzz;
|
|
|
|
temporary19_.x = _e4383.x;
|
|
|
|
temporary19_.y = _e4383.y;
|
|
|
|
temporary19_.z = _e4383.z;
|
|
|
|
let _e4392: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary13_.x = _e4392.wwww.x;
|
|
|
|
let _e4396: vec4<f32> = temporary15_;
|
|
|
|
let _e4398: vec4<f32> = temporary18_;
|
|
|
|
let _e4400: vec4<f32> = (_e4396.xyzz - _e4398.xyzz);
|
|
|
|
temporary12_.x = _e4400.x;
|
|
|
|
temporary12_.y = _e4400.y;
|
|
|
|
temporary12_.z = _e4400.z;
|
|
|
|
let _e4407: vec4<f32> = temporary12_;
|
|
|
|
let _e4409: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.y = dot(_e4407.xyz, _e4409.xyz);
|
|
|
|
let _e4413: vec4<f32> = temporary13_;
|
|
|
|
let _e4415: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = (_e4413.yyyy * _e4415.yyyy).x;
|
|
|
|
let _e4420: vec4<f32> = temporary12_;
|
|
|
|
let _e4422: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.x = dot(_e4420.xyz, _e4422.xyz);
|
|
|
|
let _e4426: vec4<f32> = temporary3_;
|
|
|
|
let _e4428: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = (_e4426.wwww - _e4428.xxxx).x;
|
|
|
|
let _e4433: vec4<f32> = temporary2_;
|
|
|
|
let _e4435: vec4<f32> = temporary2_;
|
|
|
|
temporary14_.z = (_e4433.wwww * _e4435.wwww).x;
|
|
|
|
let _e4440: vec4<f32> = temporary14_;
|
|
|
|
let _e4442: vec4<f32> = temporary14_;
|
|
|
|
temporary13_.z = (_e4440.yyyy + _e4442.zzzz).x;
|
|
|
|
let _e4449: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4451: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e4449.xxxx < _e4451.zzzz)).x;
|
|
|
|
let _e4457: vec4<f32> = temporary3_;
|
|
|
|
let _e4461: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4457.wwww != _e4461.xxxx)) {
|
|
|
|
let _e4465: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = sqrt(_e4465.zzzz).x;
|
|
|
|
let _e4470: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.x = -(_e4470.yyyy).x;
|
|
|
|
let _e4475: vec4<f32> = temporary14_;
|
|
|
|
let _e4477: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.y = (_e4475.xxxx - _e4477.zzzz).x;
|
|
|
|
let _e4482: vec4<f32> = temporary14_;
|
|
|
|
temporary3_.w = _e4482.yyyy.x;
|
|
|
|
let _e4488: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4490: vec4<f32> = temporary3_;
|
|
|
|
temporary14_.x = vec4<f32>((_e4488.xxxx < _e4490.wwww)).x;
|
|
|
|
let _e4496: vec4<f32> = temporary14_;
|
|
|
|
let _e4500: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4496.xxxx != _e4500.xxxx)) {
|
|
|
|
let _e4504: vec4<f32> = temporary3_;
|
|
|
|
temporary13_.x = _e4504.wwww.x;
|
|
|
|
let _e4508: vec4<f32> = temporary17_;
|
|
|
|
let _e4510: vec4<f32> = temporary3_;
|
|
|
|
let _e4512: vec4<f32> = (_e4508.xyzz * _e4510.wwww);
|
|
|
|
temporary14_.x = _e4512.x;
|
|
|
|
temporary14_.y = _e4512.y;
|
|
|
|
temporary14_.z = _e4512.z;
|
|
|
|
let _e4519: vec4<f32> = temporary15_;
|
|
|
|
let _e4521: vec4<f32> = temporary14_;
|
|
|
|
let _e4523: vec4<f32> = (_e4519.xyzz + _e4521.xyzz);
|
|
|
|
temporary20_.x = _e4523.x;
|
|
|
|
temporary20_.y = _e4523.y;
|
|
|
|
temporary20_.z = _e4523.z;
|
|
|
|
let _e4530: vec4<f32> = temporary20_;
|
|
|
|
let _e4532: vec4<f32> = temporary18_;
|
|
|
|
let _e4534: vec4<f32> = (_e4530.xyzz - _e4532.xyzz);
|
|
|
|
temporary16_.x = _e4534.x;
|
|
|
|
temporary16_.y = _e4534.y;
|
|
|
|
temporary16_.z = _e4534.z;
|
|
|
|
let _e4541: vec4<f32> = temporary16_;
|
|
|
|
let _e4543: vec3<f32> = normalize(_e4541.xyz);
|
|
|
|
temporary19_.x = _e4543.x;
|
|
|
|
temporary19_.y = _e4543.y;
|
|
|
|
temporary19_.z = _e4543.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4550: vec4<f32> = temporary13_;
|
|
|
|
temporary4_.y = _e4550.xxxx.x;
|
|
|
|
let _e4554: vec4<f32> = temporary19_;
|
|
|
|
let _e4555: vec4<f32> = _e4554.xyzz;
|
|
|
|
temporary3_.x = _e4555.x;
|
|
|
|
temporary3_.y = _e4555.y;
|
|
|
|
temporary3_.z = _e4555.z;
|
|
|
|
let _e4562: vec4<f32> = temporary4_;
|
|
|
|
let _e4564: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e4562.yyyy < _e4564.zzzz)).x;
|
|
|
|
let _e4570: vec4<f32> = temporary8_;
|
|
|
|
let _e4574: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4570.zzzz != _e4574.xxxx)) {
|
|
|
|
let _e4578: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e4578.yyyy.x;
|
|
|
|
let _e4582: vec4<f32> = temporary3_;
|
|
|
|
let _e4583: vec4<f32> = _e4582.xyzz;
|
|
|
|
temporary6_.x = _e4583.x;
|
|
|
|
temporary6_.y = _e4583.y;
|
|
|
|
temporary6_.z = _e4583.z;
|
|
|
|
let _e4592: vec4<f32> = constant_registers[8u];
|
|
|
|
let _e4593: vec4<f32> = _e4592.xyzz;
|
|
|
|
temporary7_.x = _e4593.x;
|
|
|
|
temporary7_.y = _e4593.y;
|
|
|
|
temporary7_.z = _e4593.z;
|
|
|
|
let _e4602: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e4602.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4606: vec4<f32> = temporary2_;
|
|
|
|
let _e4607: vec4<f32> = _e4606.xyzz;
|
|
|
|
temporary15_.x = _e4607.x;
|
|
|
|
temporary15_.y = _e4607.y;
|
|
|
|
temporary15_.z = _e4607.z;
|
|
|
|
let _e4614: vec4<f32> = temporary9_;
|
|
|
|
let _e4615: vec4<f32> = _e4614.xyzz;
|
|
|
|
temporary17_.x = _e4615.x;
|
|
|
|
temporary17_.y = _e4615.y;
|
|
|
|
temporary17_.z = _e4615.z;
|
|
|
|
let _e4624: vec4<f32> = constant_registers[10u];
|
|
|
|
let _e4625: vec4<f32> = _e4624.xyzz;
|
|
|
|
temporary18_.x = _e4625.x;
|
|
|
|
temporary18_.y = _e4625.y;
|
|
|
|
temporary18_.z = _e4625.z;
|
|
|
|
let _e4634: vec4<f32> = constant_registers[12u];
|
|
|
|
temporary2_.w = _e4634.xxxx.x;
|
|
|
|
let _e4638: vec4<f32> = temporary3_;
|
|
|
|
let _e4639: vec4<f32> = _e4638.xyzz;
|
|
|
|
temporary19_.x = _e4639.x;
|
|
|
|
temporary19_.y = _e4639.y;
|
|
|
|
temporary19_.z = _e4639.z;
|
|
|
|
let _e4648: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary13_.x = _e4648.wwww.x;
|
|
|
|
let _e4652: vec4<f32> = temporary15_;
|
|
|
|
let _e4654: vec4<f32> = temporary18_;
|
|
|
|
let _e4656: vec4<f32> = (_e4652.xyzz - _e4654.xyzz);
|
|
|
|
temporary12_.x = _e4656.x;
|
|
|
|
temporary12_.y = _e4656.y;
|
|
|
|
temporary12_.z = _e4656.z;
|
|
|
|
let _e4663: vec4<f32> = temporary12_;
|
|
|
|
let _e4665: vec4<f32> = temporary17_;
|
|
|
|
temporary13_.y = dot(_e4663.xyz, _e4665.xyz);
|
|
|
|
let _e4669: vec4<f32> = temporary13_;
|
|
|
|
let _e4671: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = (_e4669.yyyy * _e4671.yyyy).x;
|
|
|
|
let _e4676: vec4<f32> = temporary12_;
|
|
|
|
let _e4678: vec4<f32> = temporary12_;
|
|
|
|
temporary14_.x = dot(_e4676.xyz, _e4678.xyz);
|
|
|
|
let _e4682: vec4<f32> = temporary3_;
|
|
|
|
let _e4684: vec4<f32> = temporary14_;
|
|
|
|
temporary14_.y = (_e4682.wwww - _e4684.xxxx).x;
|
|
|
|
let _e4689: vec4<f32> = temporary2_;
|
|
|
|
let _e4691: vec4<f32> = temporary2_;
|
|
|
|
temporary14_.z = (_e4689.wwww * _e4691.wwww).x;
|
|
|
|
let _e4696: vec4<f32> = temporary14_;
|
|
|
|
let _e4698: vec4<f32> = temporary14_;
|
|
|
|
temporary13_.z = (_e4696.yyyy + _e4698.zzzz).x;
|
|
|
|
let _e4705: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4707: vec4<f32> = temporary13_;
|
|
|
|
temporary3_.w = vec4<f32>((_e4705.xxxx < _e4707.zzzz)).x;
|
|
|
|
let _e4713: vec4<f32> = temporary3_;
|
|
|
|
let _e4717: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4713.wwww != _e4717.xxxx)) {
|
|
|
|
let _e4721: vec4<f32> = temporary13_;
|
|
|
|
temporary13_.z = sqrt(_e4721.zzzz).x;
|
|
|
|
let _e4726: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.x = -(_e4726.yyyy).x;
|
|
|
|
let _e4731: vec4<f32> = temporary14_;
|
|
|
|
let _e4733: vec4<f32> = temporary13_;
|
|
|
|
temporary14_.y = (_e4731.xxxx - _e4733.zzzz).x;
|
|
|
|
let _e4738: vec4<f32> = temporary14_;
|
|
|
|
temporary3_.w = _e4738.yyyy.x;
|
|
|
|
let _e4744: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e4746: vec4<f32> = temporary3_;
|
|
|
|
temporary14_.x = vec4<f32>((_e4744.xxxx < _e4746.wwww)).x;
|
|
|
|
let _e4752: vec4<f32> = temporary14_;
|
|
|
|
let _e4756: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4752.xxxx != _e4756.xxxx)) {
|
|
|
|
let _e4760: vec4<f32> = temporary3_;
|
|
|
|
temporary13_.x = _e4760.wwww.x;
|
|
|
|
let _e4764: vec4<f32> = temporary17_;
|
|
|
|
let _e4766: vec4<f32> = temporary3_;
|
|
|
|
let _e4768: vec4<f32> = (_e4764.xyzz * _e4766.wwww);
|
|
|
|
temporary14_.x = _e4768.x;
|
|
|
|
temporary14_.y = _e4768.y;
|
|
|
|
temporary14_.z = _e4768.z;
|
|
|
|
let _e4775: vec4<f32> = temporary15_;
|
|
|
|
let _e4777: vec4<f32> = temporary14_;
|
|
|
|
let _e4779: vec4<f32> = (_e4775.xyzz + _e4777.xyzz);
|
|
|
|
temporary20_.x = _e4779.x;
|
|
|
|
temporary20_.y = _e4779.y;
|
|
|
|
temporary20_.z = _e4779.z;
|
|
|
|
let _e4786: vec4<f32> = temporary20_;
|
|
|
|
let _e4788: vec4<f32> = temporary18_;
|
|
|
|
let _e4790: vec4<f32> = (_e4786.xyzz - _e4788.xyzz);
|
|
|
|
temporary16_.x = _e4790.x;
|
|
|
|
temporary16_.y = _e4790.y;
|
|
|
|
temporary16_.z = _e4790.z;
|
|
|
|
let _e4797: vec4<f32> = temporary16_;
|
|
|
|
let _e4799: vec3<f32> = normalize(_e4797.xyz);
|
|
|
|
temporary19_.x = _e4799.x;
|
|
|
|
temporary19_.y = _e4799.y;
|
|
|
|
temporary19_.z = _e4799.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4806: vec4<f32> = temporary13_;
|
|
|
|
temporary4_.y = _e4806.xxxx.x;
|
|
|
|
let _e4810: vec4<f32> = temporary19_;
|
|
|
|
let _e4811: vec4<f32> = _e4810.xyzz;
|
|
|
|
temporary3_.x = _e4811.x;
|
|
|
|
temporary3_.y = _e4811.y;
|
|
|
|
temporary3_.z = _e4811.z;
|
|
|
|
let _e4818: vec4<f32> = temporary4_;
|
|
|
|
let _e4820: vec4<f32> = temporary4_;
|
|
|
|
temporary8_.z = vec4<f32>((_e4818.yyyy < _e4820.zzzz)).x;
|
|
|
|
let _e4826: vec4<f32> = temporary8_;
|
|
|
|
let _e4830: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4826.zzzz != _e4830.xxxx)) {
|
|
|
|
let _e4834: vec4<f32> = temporary4_;
|
|
|
|
temporary4_.z = _e4834.yyyy.x;
|
|
|
|
let _e4838: vec4<f32> = temporary3_;
|
|
|
|
let _e4839: vec4<f32> = _e4838.xyzz;
|
|
|
|
temporary6_.x = _e4839.x;
|
|
|
|
temporary6_.y = _e4839.y;
|
|
|
|
temporary6_.z = _e4839.z;
|
|
|
|
let _e4848: vec4<f32> = constant_registers[11u];
|
|
|
|
let _e4849: vec4<f32> = _e4848.xyzz;
|
|
|
|
temporary7_.x = _e4849.x;
|
|
|
|
temporary7_.y = _e4849.y;
|
|
|
|
temporary7_.z = _e4849.z;
|
|
|
|
let _e4858: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.z = _e4858.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4862: vec4<f32> = temporary11_;
|
|
|
|
let _e4866: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary11_.y = (_e4862.yyyy + _e4866.yyyy).x;
|
|
|
|
let _e4871: vec4<f32> = temporary1_;
|
|
|
|
let _e4875: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.z = vec4<f32>((_e4871.zzzz == _e4875.xxxx)).x;
|
|
|
|
let _e4881: vec4<f32> = temporary8_;
|
|
|
|
let _e4885: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e4881.zzzz != _e4885.xxxx)) {
|
|
|
|
let _e4891: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary11_.z = _e4891.yyyy.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
} else {
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e4895: vec4<f32> = temporary9_;
|
|
|
|
let _e4897: vec4<f32> = temporary4_;
|
|
|
|
let _e4899: vec4<f32> = (_e4895.xyzz * _e4897.zzzz);
|
|
|
|
temporary15_.x = _e4899.x;
|
|
|
|
temporary15_.y = _e4899.y;
|
|
|
|
temporary15_.z = _e4899.z;
|
|
|
|
let _e4906: vec4<f32> = temporary2_;
|
|
|
|
let _e4908: vec4<f32> = temporary15_;
|
|
|
|
let _e4910: vec4<f32> = (_e4906.xyzz + _e4908.xyzz);
|
|
|
|
temporary2_.x = _e4910.x;
|
|
|
|
temporary2_.y = _e4910.y;
|
|
|
|
temporary2_.z = _e4910.z;
|
|
|
|
let _e4917: vec4<f32> = temporary9_;
|
|
|
|
let _e4919: vec4<f32> = temporary6_;
|
|
|
|
temporary8_.z = dot(_e4917.xyz, _e4919.xyz);
|
|
|
|
let _e4923: vec4<f32> = temporary8_;
|
|
|
|
let _e4927: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary2_.w = (_e4923.zzzz * _e4927.xxxx).x;
|
|
|
|
let _e4932: vec4<f32> = temporary2_;
|
|
|
|
let _e4934: vec4<f32> = temporary6_;
|
|
|
|
let _e4936: vec4<f32> = (_e4932.wwww * _e4934.xyzz);
|
|
|
|
temporary15_.x = _e4936.x;
|
|
|
|
temporary15_.y = _e4936.y;
|
|
|
|
temporary15_.z = _e4936.z;
|
|
|
|
let _e4943: vec4<f32> = temporary9_;
|
|
|
|
let _e4945: vec4<f32> = temporary15_;
|
|
|
|
let _e4947: vec4<f32> = (_e4943.xyzz - _e4945.xyzz);
|
|
|
|
temporary9_.x = _e4947.x;
|
|
|
|
temporary9_.y = _e4947.y;
|
|
|
|
temporary9_.z = _e4947.z;
|
|
|
|
let _e4954: vec4<f32> = temporary9_;
|
|
|
|
let _e4958: vec4<f32> = constant_registers[18u];
|
|
|
|
let _e4960: vec4<f32> = (_e4954.xyzz * _e4958.yyyy);
|
|
|
|
temporary15_.x = _e4960.x;
|
|
|
|
temporary15_.y = _e4960.y;
|
|
|
|
temporary15_.z = _e4960.z;
|
|
|
|
let _e4967: vec4<f32> = temporary2_;
|
|
|
|
let _e4969: vec4<f32> = temporary15_;
|
|
|
|
let _e4971: vec4<f32> = (_e4967.xyzz + _e4969.xyzz);
|
|
|
|
temporary2_.x = _e4971.x;
|
|
|
|
temporary2_.y = _e4971.y;
|
|
|
|
temporary2_.z = _e4971.z;
|
|
|
|
let _e4980: vec4<f32> = constant_registers[15u];
|
|
|
|
let _e4982: vec4<f32> = temporary2_;
|
|
|
|
let _e4984: vec4<f32> = (_e4980.xyzz - _e4982.xyzz);
|
|
|
|
temporary5_.x = _e4984.x;
|
|
|
|
temporary5_.y = _e4984.y;
|
|
|
|
temporary5_.z = _e4984.z;
|
|
|
|
let _e4991: vec4<f32> = temporary5_;
|
|
|
|
let _e4993: vec3<f32> = normalize(_e4991.xyz);
|
|
|
|
temporary10_.x = _e4993.x;
|
|
|
|
temporary10_.y = _e4993.y;
|
|
|
|
temporary10_.z = _e4993.z;
|
|
|
|
let _e5000: vec4<f32> = temporary5_;
|
|
|
|
let _e5002: vec4<f32> = temporary5_;
|
|
|
|
temporary8_.z = dot(_e5000.xyz, _e5002.xyz);
|
|
|
|
let _e5006: vec4<f32> = temporary8_;
|
|
|
|
temporary1_.y = sqrt(_e5006.zzzz).x;
|
|
|
|
let _e5011: vec4<f32> = temporary6_;
|
|
|
|
let _e5013: vec4<f32> = temporary10_;
|
|
|
|
temporary8_.z = dot(_e5011.xyz, _e5013.xyz);
|
|
|
|
let _e5017: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = saturate(_e5017.zzzz).x;
|
|
|
|
let _e5022: vec4<f32> = temporary1_;
|
|
|
|
let _e5024: vec4<f32> = temporary1_;
|
|
|
|
temporary15_.x = (_e5022.yyyy * _e5024.yyyy).x;
|
|
|
|
let _e5029: vec4<f32> = temporary15_;
|
|
|
|
let _e5033: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary15_.y = (_e5029.xxxx * _e5033.zzzz).x;
|
|
|
|
let _e5040: vec4<f32> = constant_registers[18u];
|
|
|
|
let _e5042: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.z = (_e5040.wwww + _e5042.yyyy).x;
|
|
|
|
let _e5047: vec4<f32> = temporary2_;
|
|
|
|
let _e5049: vec4<f32> = temporary15_;
|
|
|
|
temporary1_.x = (_e5047.wwww / _e5049.zzzz).x;
|
|
|
|
let _e5054: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.x = _e5054.xxxx.x;
|
|
|
|
let _e5060: vec4<f32> = constant_registers[6u];
|
|
|
|
temporary2_.w = _e5060.xxxx.x;
|
|
|
|
let _e5066: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary19_.x = _e5066.wwww.x;
|
|
|
|
let _e5070: vec4<f32> = temporary2_;
|
|
|
|
let _e5074: vec4<f32> = constant_registers[4u];
|
|
|
|
let _e5076: vec4<f32> = (_e5070.xyzz - _e5074.xyzz);
|
|
|
|
temporary13_.x = _e5076.x;
|
|
|
|
temporary13_.y = _e5076.y;
|
|
|
|
temporary13_.z = _e5076.z;
|
|
|
|
let _e5083: vec4<f32> = temporary13_;
|
|
|
|
let _e5085: vec4<f32> = temporary10_;
|
|
|
|
temporary19_.y = dot(_e5083.xyz, _e5085.xyz);
|
|
|
|
let _e5089: vec4<f32> = temporary19_;
|
|
|
|
let _e5091: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e5089.yyyy * _e5091.yyyy).x;
|
|
|
|
let _e5096: vec4<f32> = temporary13_;
|
|
|
|
let _e5098: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = dot(_e5096.xyz, _e5098.xyz);
|
|
|
|
let _e5102: vec4<f32> = temporary1_;
|
|
|
|
let _e5104: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e5102.wwww - _e5104.xxxx).x;
|
|
|
|
let _e5109: vec4<f32> = temporary2_;
|
|
|
|
let _e5111: vec4<f32> = temporary2_;
|
|
|
|
temporary12_.z = (_e5109.wwww * _e5111.wwww).x;
|
|
|
|
let _e5116: vec4<f32> = temporary12_;
|
|
|
|
let _e5118: vec4<f32> = temporary12_;
|
|
|
|
temporary19_.z = (_e5116.yyyy + _e5118.zzzz).x;
|
|
|
|
let _e5125: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e5127: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = vec4<f32>((_e5125.xxxx < _e5127.zzzz)).x;
|
|
|
|
let _e5133: vec4<f32> = temporary1_;
|
|
|
|
let _e5137: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5133.wwww != _e5137.xxxx)) {
|
|
|
|
let _e5141: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = sqrt(_e5141.zzzz).x;
|
|
|
|
let _e5146: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.x = -(_e5146.yyyy).x;
|
|
|
|
let _e5151: vec4<f32> = temporary12_;
|
|
|
|
let _e5153: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e5151.xxxx - _e5153.zzzz).x;
|
|
|
|
let _e5160: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e5162: vec4<f32> = temporary1_;
|
|
|
|
temporary12_.x = vec4<f32>((_e5160.xxxx < _e5162.wwww)).x;
|
|
|
|
let _e5168: vec4<f32> = temporary12_;
|
|
|
|
let _e5172: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5168.xxxx != _e5172.xxxx)) {
|
|
|
|
let _e5176: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = _e5176.wwww.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5180: vec4<f32> = temporary19_;
|
|
|
|
let _e5182: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.z = vec4<f32>((_e5180.xxxx < _e5182.yyyy)).x;
|
|
|
|
let _e5188: vec4<f32> = temporary8_;
|
|
|
|
let _e5192: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5188.zzzz != _e5192.xxxx)) {
|
|
|
|
let _e5198: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e5198.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5204: vec4<f32> = constant_registers[9u];
|
|
|
|
temporary2_.w = _e5204.xxxx.x;
|
|
|
|
let _e5210: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary19_.x = _e5210.wwww.x;
|
|
|
|
let _e5214: vec4<f32> = temporary2_;
|
|
|
|
let _e5218: vec4<f32> = constant_registers[7u];
|
|
|
|
let _e5220: vec4<f32> = (_e5214.xyzz - _e5218.xyzz);
|
|
|
|
temporary13_.x = _e5220.x;
|
|
|
|
temporary13_.y = _e5220.y;
|
|
|
|
temporary13_.z = _e5220.z;
|
|
|
|
let _e5227: vec4<f32> = temporary13_;
|
|
|
|
let _e5229: vec4<f32> = temporary10_;
|
|
|
|
temporary19_.y = dot(_e5227.xyz, _e5229.xyz);
|
|
|
|
let _e5233: vec4<f32> = temporary19_;
|
|
|
|
let _e5235: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e5233.yyyy * _e5235.yyyy).x;
|
|
|
|
let _e5240: vec4<f32> = temporary13_;
|
|
|
|
let _e5242: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = dot(_e5240.xyz, _e5242.xyz);
|
|
|
|
let _e5246: vec4<f32> = temporary1_;
|
|
|
|
let _e5248: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e5246.wwww - _e5248.xxxx).x;
|
|
|
|
let _e5253: vec4<f32> = temporary2_;
|
|
|
|
let _e5255: vec4<f32> = temporary2_;
|
|
|
|
temporary12_.z = (_e5253.wwww * _e5255.wwww).x;
|
|
|
|
let _e5260: vec4<f32> = temporary12_;
|
|
|
|
let _e5262: vec4<f32> = temporary12_;
|
|
|
|
temporary19_.z = (_e5260.yyyy + _e5262.zzzz).x;
|
|
|
|
let _e5269: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e5271: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = vec4<f32>((_e5269.xxxx < _e5271.zzzz)).x;
|
|
|
|
let _e5277: vec4<f32> = temporary1_;
|
|
|
|
let _e5281: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5277.wwww != _e5281.xxxx)) {
|
|
|
|
let _e5285: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = sqrt(_e5285.zzzz).x;
|
|
|
|
let _e5290: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.x = -(_e5290.yyyy).x;
|
|
|
|
let _e5295: vec4<f32> = temporary12_;
|
|
|
|
let _e5297: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e5295.xxxx - _e5297.zzzz).x;
|
|
|
|
let _e5304: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e5306: vec4<f32> = temporary1_;
|
|
|
|
temporary12_.x = vec4<f32>((_e5304.xxxx < _e5306.wwww)).x;
|
|
|
|
let _e5312: vec4<f32> = temporary12_;
|
|
|
|
let _e5316: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5312.xxxx != _e5316.xxxx)) {
|
|
|
|
let _e5320: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = _e5320.wwww.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5324: vec4<f32> = temporary19_;
|
|
|
|
let _e5326: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.z = vec4<f32>((_e5324.xxxx < _e5326.yyyy)).x;
|
|
|
|
let _e5332: vec4<f32> = temporary8_;
|
|
|
|
let _e5336: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5332.zzzz != _e5336.xxxx)) {
|
|
|
|
let _e5342: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e5342.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5346: vec4<f32> = temporary2_;
|
|
|
|
let _e5347: vec4<f32> = _e5346.xyzz;
|
|
|
|
temporary15_.x = _e5347.x;
|
|
|
|
temporary15_.y = _e5347.y;
|
|
|
|
temporary15_.z = _e5347.z;
|
|
|
|
let _e5354: vec4<f32> = temporary10_;
|
|
|
|
let _e5355: vec4<f32> = _e5354.xyzz;
|
|
|
|
temporary17_.x = _e5355.x;
|
|
|
|
temporary17_.y = _e5355.y;
|
|
|
|
temporary17_.z = _e5355.z;
|
|
|
|
let _e5364: vec4<f32> = constant_registers[12u];
|
|
|
|
temporary2_.w = _e5364.xxxx.x;
|
|
|
|
let _e5370: vec4<f32> = constant_registers[17u];
|
|
|
|
temporary19_.x = _e5370.wwww.x;
|
|
|
|
let _e5374: vec4<f32> = temporary15_;
|
|
|
|
let _e5378: vec4<f32> = constant_registers[10u];
|
|
|
|
let _e5380: vec4<f32> = (_e5374.xyzz - _e5378.xyzz);
|
|
|
|
temporary13_.x = _e5380.x;
|
|
|
|
temporary13_.y = _e5380.y;
|
|
|
|
temporary13_.z = _e5380.z;
|
|
|
|
let _e5387: vec4<f32> = temporary13_;
|
|
|
|
let _e5389: vec4<f32> = temporary17_;
|
|
|
|
temporary19_.y = dot(_e5387.xyz, _e5389.xyz);
|
|
|
|
let _e5393: vec4<f32> = temporary19_;
|
|
|
|
let _e5395: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e5393.yyyy * _e5395.yyyy).x;
|
|
|
|
let _e5400: vec4<f32> = temporary13_;
|
|
|
|
let _e5402: vec4<f32> = temporary13_;
|
|
|
|
temporary12_.x = dot(_e5400.xyz, _e5402.xyz);
|
|
|
|
let _e5406: vec4<f32> = temporary1_;
|
|
|
|
let _e5408: vec4<f32> = temporary12_;
|
|
|
|
temporary12_.y = (_e5406.wwww - _e5408.xxxx).x;
|
|
|
|
let _e5413: vec4<f32> = temporary2_;
|
|
|
|
let _e5415: vec4<f32> = temporary2_;
|
|
|
|
temporary12_.z = (_e5413.wwww * _e5415.wwww).x;
|
|
|
|
let _e5420: vec4<f32> = temporary12_;
|
|
|
|
let _e5422: vec4<f32> = temporary12_;
|
|
|
|
temporary19_.z = (_e5420.yyyy + _e5422.zzzz).x;
|
|
|
|
let _e5429: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e5431: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = vec4<f32>((_e5429.xxxx < _e5431.zzzz)).x;
|
|
|
|
let _e5437: vec4<f32> = temporary1_;
|
|
|
|
let _e5441: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5437.wwww != _e5441.xxxx)) {
|
|
|
|
let _e5445: vec4<f32> = temporary19_;
|
|
|
|
temporary19_.z = sqrt(_e5445.zzzz).x;
|
|
|
|
let _e5450: vec4<f32> = temporary19_;
|
|
|
|
temporary12_.x = -(_e5450.yyyy).x;
|
|
|
|
let _e5455: vec4<f32> = temporary12_;
|
|
|
|
let _e5457: vec4<f32> = temporary19_;
|
|
|
|
temporary1_.w = (_e5455.xxxx - _e5457.zzzz).x;
|
|
|
|
let _e5464: vec4<f32> = constant_registers[16u];
|
|
|
|
let _e5466: vec4<f32> = temporary1_;
|
|
|
|
temporary12_.x = vec4<f32>((_e5464.xxxx < _e5466.wwww)).x;
|
|
|
|
let _e5472: vec4<f32> = temporary12_;
|
|
|
|
let _e5476: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5472.xxxx != _e5476.xxxx)) {
|
|
|
|
let _e5480: vec4<f32> = temporary1_;
|
|
|
|
temporary19_.x = _e5480.wwww.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5484: vec4<f32> = temporary19_;
|
|
|
|
let _e5486: vec4<f32> = temporary1_;
|
|
|
|
temporary8_.z = vec4<f32>((_e5484.xxxx < _e5486.yyyy)).x;
|
|
|
|
let _e5492: vec4<f32> = temporary8_;
|
|
|
|
let _e5496: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5492.zzzz != _e5496.xxxx)) {
|
|
|
|
let _e5502: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.x = _e5502.xxxx.x;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5506: vec4<f32> = temporary6_;
|
|
|
|
temporary8_.z = saturate(_e5506.yyyy).x;
|
|
|
|
let _e5511: vec4<f32> = temporary8_;
|
|
|
|
let _e5515: vec4<f32> = constant_registers[19u];
|
|
|
|
temporary2_.w = (_e5511.zzzz * _e5515.xxxx).x;
|
|
|
|
let _e5520: vec4<f32> = temporary8_;
|
|
|
|
let _e5522: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.x = (_e5520.xxxx + _e5522.wwww).x;
|
|
|
|
let _e5527: vec4<f32> = temporary8_;
|
|
|
|
let _e5531: vec4<f32> = constant_registers[19u];
|
|
|
|
temporary8_.z = (_e5527.xxxx * _e5531.yyyy).x;
|
|
|
|
let _e5538: vec4<f32> = constant_registers[19u];
|
|
|
|
let _e5540: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = (_e5538.zzzz + _e5540.zzzz).x;
|
|
|
|
let _e5545: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.y = _e5545.wwww.x;
|
|
|
|
let _e5549: vec4<f32> = temporary1_;
|
|
|
|
let _e5553: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary8_.z = vec4<f32>((_e5549.zzzz == _e5553.yyyy)).x;
|
|
|
|
let _e5559: vec4<f32> = temporary8_;
|
|
|
|
let _e5563: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5559.zzzz != _e5563.xxxx)) {
|
|
|
|
let _e5567: vec4<f32> = temporary2_;
|
|
|
|
temporary8_.z = fract(_e5567.xxxx).x;
|
|
|
|
let _e5572: vec4<f32> = temporary2_;
|
|
|
|
let _e5574: vec4<f32> = temporary8_;
|
|
|
|
temporary2_.w = (_e5572.xxxx - _e5574.zzzz).x;
|
|
|
|
let _e5579: vec4<f32> = temporary2_;
|
|
|
|
temporary15_.x = fract(_e5579.zzzz).x;
|
|
|
|
let _e5584: vec4<f32> = temporary2_;
|
|
|
|
let _e5586: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.y = (_e5584.zzzz - _e5586.xxxx).x;
|
|
|
|
let _e5591: vec4<f32> = temporary2_;
|
|
|
|
let _e5593: vec4<f32> = temporary15_;
|
|
|
|
temporary15_.z = (_e5591.wwww + _e5593.yyyy).x;
|
|
|
|
let _e5598: vec4<f32> = temporary15_;
|
|
|
|
let _e5602: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary1_.x = (_e5598.zzzz / _e5602.xxxx).x;
|
|
|
|
let _e5607: vec4<f32> = temporary1_;
|
|
|
|
temporary17_.x = fract(_e5607.xxxx).x;
|
|
|
|
let _e5612: vec4<f32> = temporary17_;
|
|
|
|
let _e5616: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary17_.y = (_e5612.xxxx * _e5616.xxxx).x;
|
|
|
|
let _e5621: vec4<f32> = temporary17_;
|
|
|
|
let _e5625: vec4<f32> = constant_registers[16u];
|
|
|
|
temporary17_.z = vec4<f32>((_e5621.yyyy == _e5625.yyyy)).x;
|
|
|
|
let _e5631: vec4<f32> = temporary17_;
|
|
|
|
let _e5635: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5631.zzzz != _e5635.xxxx)) {
|
|
|
|
let _e5641: vec4<f32> = constant_registers[13u];
|
|
|
|
let _e5643: vec4<f32> = temporary8_;
|
|
|
|
let _e5645: vec4<f32> = (_e5641.xyzz * _e5643.yyyy);
|
|
|
|
temporary15_.x = _e5645.x;
|
|
|
|
temporary15_.y = _e5645.y;
|
|
|
|
temporary15_.z = _e5645.z;
|
|
|
|
let _e5652: vec4<f32> = temporary0_;
|
|
|
|
let _e5654: vec4<f32> = temporary15_;
|
|
|
|
let _e5656: vec4<f32> = (_e5652.xyzz + _e5654.xyzz);
|
|
|
|
temporary0_.x = _e5656.x;
|
|
|
|
temporary0_.y = _e5656.y;
|
|
|
|
temporary0_.z = _e5656.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
} else {
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5665: vec4<f32> = constant_registers[14u];
|
|
|
|
let _e5667: vec4<f32> = temporary8_;
|
|
|
|
let _e5669: vec4<f32> = (_e5665.xyzz * _e5667.yyyy);
|
|
|
|
temporary15_.x = _e5669.x;
|
|
|
|
temporary15_.y = _e5669.y;
|
|
|
|
temporary15_.z = _e5669.z;
|
|
|
|
let _e5676: vec4<f32> = temporary0_;
|
|
|
|
let _e5678: vec4<f32> = temporary15_;
|
|
|
|
let _e5680: vec4<f32> = (_e5676.xyzz + _e5678.xyzz);
|
|
|
|
temporary0_.x = _e5680.x;
|
|
|
|
temporary0_.y = _e5680.y;
|
|
|
|
temporary0_.z = _e5680.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5687: vec4<f32> = temporary1_;
|
|
|
|
let _e5691: vec4<f32> = constant_registers[18u];
|
|
|
|
temporary8_.z = vec4<f32>((_e5687.zzzz == _e5691.xxxx)).x;
|
|
|
|
let _e5697: vec4<f32> = temporary8_;
|
|
|
|
let _e5701: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5697.zzzz != _e5701.xxxx)) {
|
|
|
|
let _e5705: vec4<f32> = temporary7_;
|
|
|
|
let _e5707: vec4<f32> = temporary8_;
|
|
|
|
let _e5709: vec4<f32> = (_e5705.xyzz * _e5707.yyyy);
|
|
|
|
temporary15_.x = _e5709.x;
|
|
|
|
temporary15_.y = _e5709.y;
|
|
|
|
temporary15_.z = _e5709.z;
|
|
|
|
let _e5716: vec4<f32> = temporary0_;
|
|
|
|
let _e5718: vec4<f32> = temporary15_;
|
|
|
|
let _e5720: vec4<f32> = (_e5716.xyzz + _e5718.xyzz);
|
|
|
|
temporary0_.x = _e5720.x;
|
|
|
|
temporary0_.y = _e5720.y;
|
|
|
|
temporary0_.z = _e5720.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5727: vec4<f32> = temporary9_;
|
naga-agal: Fix handling of sampler overrides
After some testing, and looking at OpenFL, I believe I've
determined the correct behavior for AGAL sampling:
Each time a Context3D.setProgram or Context3D.setSamplerStateAt
call is made, the sampler config for the used texture slot(s)
is updated with the new wrapping/filter behavior. For setProgram,
this comes from all of the 'tex' opcodes used within the program.
However, when the 'ignoresampler' flag is set in a 'tex' opcode,
the setProgram call does *not* override the existing sampler config.
As a result, that program will sample with the behavior determined
by the most recent setSamplerStateAt or setProgram call involving
the used texture slot(s).
Previously, we were always overriding the opcode sampler config
with the values from Context3D.setSamplerStateAt. However, I didn't
realize that the order of the calls matter, so none of my tests ended
up observing the effect of 'ignoresampler'.
We now need to process AGAL bytecode twice - a quick initial
parse to determine the sampler configs (which need to be updated
when we call 'setProgram'), and a second time when to build the
Naga module (which needs to wait until we have the vertex attributes
available, which can be changed by ActionScript after setting
the program).
2023-11-25 21:58:09 +00:00
|
|
|
let _e5731: vec4<f32> = textureSample(texture0_, sampler3_, _e5727.xyzz.xyz);
|
2023-03-14 02:25:53 +00:00
|
|
|
temporary1_ = _e5731;
|
|
|
|
let _e5732: vec4<f32> = temporary11_;
|
|
|
|
let _e5736: vec4<f32> = constant_registers[16u];
|
|
|
|
if all((_e5732.zzzz != _e5736.xxxx)) {
|
|
|
|
let _e5740: vec4<f32> = temporary0_;
|
|
|
|
let _e5742: vec4<f32> = temporary1_;
|
|
|
|
let _e5744: vec4<f32> = (_e5740.xyzz + _e5742.xyzz);
|
|
|
|
temporary0_.x = _e5744.x;
|
|
|
|
temporary0_.y = _e5744.y;
|
|
|
|
temporary0_.z = _e5744.z;
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
2023-03-14 02:25:53 +00:00
|
|
|
let _e5751: vec4<f32> = temporary0_;
|
|
|
|
let _e5753: vec4<f32> = temporary11_;
|
|
|
|
let _e5755: vec4<f32> = (_e5751.xyzz / _e5753.yyyy);
|
|
|
|
temporary0_.x = _e5755.x;
|
|
|
|
temporary0_.y = _e5755.y;
|
|
|
|
temporary0_.z = _e5755.z;
|
|
|
|
let _e5762: vec4<f32> = temporary0_;
|
|
|
|
dest_temp = _e5762;
|
|
|
|
let _e5763: vec4<f32> = dest_temp;
|
|
|
|
return FragmentOutput(_e5763);
|
2022-09-24 03:14:49 +00:00
|
|
|
}
|
|
|
|
|