636 lines
26 KiB
Plaintext
636 lines
26 KiB
Plaintext
---
|
|
source: render/naga-agal/tests/wgsl.rs
|
|
expression: output
|
|
---
|
|
struct FragmentOutput {
|
|
@location(0) member: vec4<f32>,
|
|
}
|
|
|
|
@group(0) @binding(1)
|
|
var<uniform> constant_registers: array<vec4<f32>, 28>;
|
|
|
|
@fragment
|
|
fn main(@location(0) param: vec4<f32>) -> FragmentOutput {
|
|
var dest_temp: vec4<f32>;
|
|
var temporary0_: vec4<f32>;
|
|
var temporary1_: vec4<f32>;
|
|
var temporary3_: vec4<f32>;
|
|
var temporary2_: vec4<f32>;
|
|
|
|
let _e3: vec4<f32> = param.xyyy;
|
|
temporary0_.x = _e3.x;
|
|
temporary0_.y = _e3.y;
|
|
let _e11: vec4<f32> = constant_registers[0u];
|
|
let _e12: vec4<f32> = _e11.xxxx;
|
|
temporary0_.z = _e12.z;
|
|
temporary0_.w = _e12.w;
|
|
let _e19: vec4<f32> = constant_registers[0u];
|
|
temporary1_.x = _e19.xxxx.x;
|
|
let _e24: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e24.yyyy).x;
|
|
let _e31: vec4<f32> = constant_registers[0u];
|
|
let _e33: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e31.zzzz * _e33.xxxx).x;
|
|
let _e39: vec4<f32> = temporary0_;
|
|
let _e41: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e39.xyw, _e41.xzw);
|
|
let _e45: vec4<f32> = temporary3_;
|
|
let _e47: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e45.xxxx * _e47.yyyy).x;
|
|
let _e52: vec4<f32> = temporary0_;
|
|
let _e56: vec4<f32> = constant_registers[3u];
|
|
let _e58: vec4<f32> = (_e52.xyyy + _e56.xyyy);
|
|
temporary0_.x = _e58.x;
|
|
temporary0_.y = _e58.y;
|
|
let _e63: vec4<f32> = temporary0_;
|
|
let _e65: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e63.xyw, _e65.xyw);
|
|
let _e70: vec4<f32> = temporary2_;
|
|
let _e74: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e70.xxxx < _e74.wwww)).x;
|
|
let _e80: vec4<f32> = temporary1_;
|
|
let _e82: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e80.xxxx + _e82.xxxx).x;
|
|
let _e87: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e87.yyyy).x;
|
|
let _e94: vec4<f32> = constant_registers[0u];
|
|
let _e96: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e94.zzzz * _e96.xxxx).x;
|
|
let _e101: vec4<f32> = temporary0_;
|
|
let _e103: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e101.xyw, _e103.xzw);
|
|
let _e107: vec4<f32> = temporary3_;
|
|
let _e109: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e107.xxxx * _e109.yyyy).x;
|
|
let _e114: vec4<f32> = temporary0_;
|
|
let _e118: vec4<f32> = constant_registers[3u];
|
|
let _e120: vec4<f32> = (_e114.xyyy + _e118.xyyy);
|
|
temporary0_.x = _e120.x;
|
|
temporary0_.y = _e120.y;
|
|
let _e125: vec4<f32> = temporary0_;
|
|
let _e127: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e125.xyw, _e127.xyw);
|
|
let _e131: vec4<f32> = temporary2_;
|
|
let _e135: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e131.xxxx < _e135.wwww)).x;
|
|
let _e141: vec4<f32> = temporary1_;
|
|
let _e143: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e141.xxxx + _e143.xxxx).x;
|
|
let _e148: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e148.yyyy).x;
|
|
let _e155: vec4<f32> = constant_registers[0u];
|
|
let _e157: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e155.zzzz * _e157.xxxx).x;
|
|
let _e162: vec4<f32> = temporary0_;
|
|
let _e164: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e162.xyw, _e164.xzw);
|
|
let _e168: vec4<f32> = temporary3_;
|
|
let _e170: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e168.xxxx * _e170.yyyy).x;
|
|
let _e175: vec4<f32> = temporary0_;
|
|
let _e179: vec4<f32> = constant_registers[3u];
|
|
let _e181: vec4<f32> = (_e175.xyyy + _e179.xyyy);
|
|
temporary0_.x = _e181.x;
|
|
temporary0_.y = _e181.y;
|
|
let _e186: vec4<f32> = temporary0_;
|
|
let _e188: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e186.xyw, _e188.xyw);
|
|
let _e192: vec4<f32> = temporary2_;
|
|
let _e196: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e192.xxxx < _e196.wwww)).x;
|
|
let _e202: vec4<f32> = temporary1_;
|
|
let _e204: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e202.xxxx + _e204.xxxx).x;
|
|
let _e209: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e209.yyyy).x;
|
|
let _e216: vec4<f32> = constant_registers[0u];
|
|
let _e218: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e216.zzzz * _e218.xxxx).x;
|
|
let _e223: vec4<f32> = temporary0_;
|
|
let _e225: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e223.xyw, _e225.xzw);
|
|
let _e229: vec4<f32> = temporary3_;
|
|
let _e231: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e229.xxxx * _e231.yyyy).x;
|
|
let _e236: vec4<f32> = temporary0_;
|
|
let _e240: vec4<f32> = constant_registers[3u];
|
|
let _e242: vec4<f32> = (_e236.xyyy + _e240.xyyy);
|
|
temporary0_.x = _e242.x;
|
|
temporary0_.y = _e242.y;
|
|
let _e247: vec4<f32> = temporary0_;
|
|
let _e249: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e247.xyw, _e249.xyw);
|
|
let _e253: vec4<f32> = temporary2_;
|
|
let _e257: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e253.xxxx < _e257.wwww)).x;
|
|
let _e263: vec4<f32> = temporary1_;
|
|
let _e265: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e263.xxxx + _e265.xxxx).x;
|
|
let _e270: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e270.yyyy).x;
|
|
let _e277: vec4<f32> = constant_registers[0u];
|
|
let _e279: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e277.zzzz * _e279.xxxx).x;
|
|
let _e284: vec4<f32> = temporary0_;
|
|
let _e286: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e284.xyw, _e286.xzw);
|
|
let _e290: vec4<f32> = temporary3_;
|
|
let _e292: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e290.xxxx * _e292.yyyy).x;
|
|
let _e297: vec4<f32> = temporary0_;
|
|
let _e301: vec4<f32> = constant_registers[3u];
|
|
let _e303: vec4<f32> = (_e297.xyyy + _e301.xyyy);
|
|
temporary0_.x = _e303.x;
|
|
temporary0_.y = _e303.y;
|
|
let _e308: vec4<f32> = temporary0_;
|
|
let _e310: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e308.xyw, _e310.xyw);
|
|
let _e314: vec4<f32> = temporary2_;
|
|
let _e318: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e314.xxxx < _e318.wwww)).x;
|
|
let _e324: vec4<f32> = temporary1_;
|
|
let _e326: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e324.xxxx + _e326.xxxx).x;
|
|
let _e331: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e331.yyyy).x;
|
|
let _e338: vec4<f32> = constant_registers[0u];
|
|
let _e340: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e338.zzzz * _e340.xxxx).x;
|
|
let _e345: vec4<f32> = temporary0_;
|
|
let _e347: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e345.xyw, _e347.xzw);
|
|
let _e351: vec4<f32> = temporary3_;
|
|
let _e353: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e351.xxxx * _e353.yyyy).x;
|
|
let _e358: vec4<f32> = temporary0_;
|
|
let _e362: vec4<f32> = constant_registers[3u];
|
|
let _e364: vec4<f32> = (_e358.xyyy + _e362.xyyy);
|
|
temporary0_.x = _e364.x;
|
|
temporary0_.y = _e364.y;
|
|
let _e369: vec4<f32> = temporary0_;
|
|
let _e371: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e369.xyw, _e371.xyw);
|
|
let _e375: vec4<f32> = temporary2_;
|
|
let _e379: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e375.xxxx < _e379.wwww)).x;
|
|
let _e385: vec4<f32> = temporary1_;
|
|
let _e387: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e385.xxxx + _e387.xxxx).x;
|
|
let _e392: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e392.yyyy).x;
|
|
let _e399: vec4<f32> = constant_registers[0u];
|
|
let _e401: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e399.zzzz * _e401.xxxx).x;
|
|
let _e406: vec4<f32> = temporary0_;
|
|
let _e408: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e406.xyw, _e408.xzw);
|
|
let _e412: vec4<f32> = temporary3_;
|
|
let _e414: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e412.xxxx * _e414.yyyy).x;
|
|
let _e419: vec4<f32> = temporary0_;
|
|
let _e423: vec4<f32> = constant_registers[3u];
|
|
let _e425: vec4<f32> = (_e419.xyyy + _e423.xyyy);
|
|
temporary0_.x = _e425.x;
|
|
temporary0_.y = _e425.y;
|
|
let _e430: vec4<f32> = temporary0_;
|
|
let _e432: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e430.xyw, _e432.xyw);
|
|
let _e436: vec4<f32> = temporary2_;
|
|
let _e440: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e436.xxxx < _e440.wwww)).x;
|
|
let _e446: vec4<f32> = temporary1_;
|
|
let _e448: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e446.xxxx + _e448.xxxx).x;
|
|
let _e453: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e453.yyyy).x;
|
|
let _e460: vec4<f32> = constant_registers[0u];
|
|
let _e462: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e460.zzzz * _e462.xxxx).x;
|
|
let _e467: vec4<f32> = temporary0_;
|
|
let _e469: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e467.xyw, _e469.xzw);
|
|
let _e473: vec4<f32> = temporary3_;
|
|
let _e475: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e473.xxxx * _e475.yyyy).x;
|
|
let _e480: vec4<f32> = temporary0_;
|
|
let _e484: vec4<f32> = constant_registers[3u];
|
|
let _e486: vec4<f32> = (_e480.xyyy + _e484.xyyy);
|
|
temporary0_.x = _e486.x;
|
|
temporary0_.y = _e486.y;
|
|
let _e491: vec4<f32> = temporary0_;
|
|
let _e493: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e491.xyw, _e493.xyw);
|
|
let _e497: vec4<f32> = temporary2_;
|
|
let _e501: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e497.xxxx < _e501.wwww)).x;
|
|
let _e507: vec4<f32> = temporary1_;
|
|
let _e509: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e507.xxxx + _e509.xxxx).x;
|
|
let _e514: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e514.yyyy).x;
|
|
let _e521: vec4<f32> = constant_registers[0u];
|
|
let _e523: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e521.zzzz * _e523.xxxx).x;
|
|
let _e528: vec4<f32> = temporary0_;
|
|
let _e530: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e528.xyw, _e530.xzw);
|
|
let _e534: vec4<f32> = temporary3_;
|
|
let _e536: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e534.xxxx * _e536.yyyy).x;
|
|
let _e541: vec4<f32> = temporary0_;
|
|
let _e545: vec4<f32> = constant_registers[3u];
|
|
let _e547: vec4<f32> = (_e541.xyyy + _e545.xyyy);
|
|
temporary0_.x = _e547.x;
|
|
temporary0_.y = _e547.y;
|
|
let _e552: vec4<f32> = temporary0_;
|
|
let _e554: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e552.xyw, _e554.xyw);
|
|
let _e558: vec4<f32> = temporary2_;
|
|
let _e562: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e558.xxxx < _e562.wwww)).x;
|
|
let _e568: vec4<f32> = temporary1_;
|
|
let _e570: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e568.xxxx + _e570.xxxx).x;
|
|
let _e575: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e575.yyyy).x;
|
|
let _e582: vec4<f32> = constant_registers[0u];
|
|
let _e584: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e582.zzzz * _e584.xxxx).x;
|
|
let _e589: vec4<f32> = temporary0_;
|
|
let _e591: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e589.xyw, _e591.xzw);
|
|
let _e595: vec4<f32> = temporary3_;
|
|
let _e597: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e595.xxxx * _e597.yyyy).x;
|
|
let _e602: vec4<f32> = temporary0_;
|
|
let _e606: vec4<f32> = constant_registers[3u];
|
|
let _e608: vec4<f32> = (_e602.xyyy + _e606.xyyy);
|
|
temporary0_.x = _e608.x;
|
|
temporary0_.y = _e608.y;
|
|
let _e613: vec4<f32> = temporary0_;
|
|
let _e615: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e613.xyw, _e615.xyw);
|
|
let _e619: vec4<f32> = temporary2_;
|
|
let _e623: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e619.xxxx < _e623.wwww)).x;
|
|
let _e629: vec4<f32> = temporary1_;
|
|
let _e631: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e629.xxxx + _e631.xxxx).x;
|
|
let _e636: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e636.yyyy).x;
|
|
let _e643: vec4<f32> = constant_registers[0u];
|
|
let _e645: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e643.zzzz * _e645.xxxx).x;
|
|
let _e650: vec4<f32> = temporary0_;
|
|
let _e652: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e650.xyw, _e652.xzw);
|
|
let _e656: vec4<f32> = temporary3_;
|
|
let _e658: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e656.xxxx * _e658.yyyy).x;
|
|
let _e663: vec4<f32> = temporary0_;
|
|
let _e667: vec4<f32> = constant_registers[3u];
|
|
let _e669: vec4<f32> = (_e663.xyyy + _e667.xyyy);
|
|
temporary0_.x = _e669.x;
|
|
temporary0_.y = _e669.y;
|
|
let _e674: vec4<f32> = temporary0_;
|
|
let _e676: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e674.xyw, _e676.xyw);
|
|
let _e680: vec4<f32> = temporary2_;
|
|
let _e684: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e680.xxxx < _e684.wwww)).x;
|
|
let _e690: vec4<f32> = temporary1_;
|
|
let _e692: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e690.xxxx + _e692.xxxx).x;
|
|
let _e697: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e697.yyyy).x;
|
|
let _e704: vec4<f32> = constant_registers[0u];
|
|
let _e706: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e704.zzzz * _e706.xxxx).x;
|
|
let _e711: vec4<f32> = temporary0_;
|
|
let _e713: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e711.xyw, _e713.xzw);
|
|
let _e717: vec4<f32> = temporary3_;
|
|
let _e719: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e717.xxxx * _e719.yyyy).x;
|
|
let _e724: vec4<f32> = temporary0_;
|
|
let _e728: vec4<f32> = constant_registers[3u];
|
|
let _e730: vec4<f32> = (_e724.xyyy + _e728.xyyy);
|
|
temporary0_.x = _e730.x;
|
|
temporary0_.y = _e730.y;
|
|
let _e735: vec4<f32> = temporary0_;
|
|
let _e737: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e735.xyw, _e737.xyw);
|
|
let _e741: vec4<f32> = temporary2_;
|
|
let _e745: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e741.xxxx < _e745.wwww)).x;
|
|
let _e751: vec4<f32> = temporary1_;
|
|
let _e753: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e751.xxxx + _e753.xxxx).x;
|
|
let _e758: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e758.yyyy).x;
|
|
let _e765: vec4<f32> = constant_registers[0u];
|
|
let _e767: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e765.zzzz * _e767.xxxx).x;
|
|
let _e772: vec4<f32> = temporary0_;
|
|
let _e774: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e772.xyw, _e774.xzw);
|
|
let _e778: vec4<f32> = temporary3_;
|
|
let _e780: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e778.xxxx * _e780.yyyy).x;
|
|
let _e785: vec4<f32> = temporary0_;
|
|
let _e789: vec4<f32> = constant_registers[3u];
|
|
let _e791: vec4<f32> = (_e785.xyyy + _e789.xyyy);
|
|
temporary0_.x = _e791.x;
|
|
temporary0_.y = _e791.y;
|
|
let _e796: vec4<f32> = temporary0_;
|
|
let _e798: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e796.xyw, _e798.xyw);
|
|
let _e802: vec4<f32> = temporary2_;
|
|
let _e806: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e802.xxxx < _e806.wwww)).x;
|
|
let _e812: vec4<f32> = temporary1_;
|
|
let _e814: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e812.xxxx + _e814.xxxx).x;
|
|
let _e819: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e819.yyyy).x;
|
|
let _e826: vec4<f32> = constant_registers[0u];
|
|
let _e828: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e826.zzzz * _e828.xxxx).x;
|
|
let _e833: vec4<f32> = temporary0_;
|
|
let _e835: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e833.xyw, _e835.xzw);
|
|
let _e839: vec4<f32> = temporary3_;
|
|
let _e841: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e839.xxxx * _e841.yyyy).x;
|
|
let _e846: vec4<f32> = temporary0_;
|
|
let _e850: vec4<f32> = constant_registers[3u];
|
|
let _e852: vec4<f32> = (_e846.xyyy + _e850.xyyy);
|
|
temporary0_.x = _e852.x;
|
|
temporary0_.y = _e852.y;
|
|
let _e857: vec4<f32> = temporary0_;
|
|
let _e859: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e857.xyw, _e859.xyw);
|
|
let _e863: vec4<f32> = temporary2_;
|
|
let _e867: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e863.xxxx < _e867.wwww)).x;
|
|
let _e873: vec4<f32> = temporary1_;
|
|
let _e875: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e873.xxxx + _e875.xxxx).x;
|
|
let _e880: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e880.yyyy).x;
|
|
let _e887: vec4<f32> = constant_registers[0u];
|
|
let _e889: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e887.zzzz * _e889.xxxx).x;
|
|
let _e894: vec4<f32> = temporary0_;
|
|
let _e896: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e894.xyw, _e896.xzw);
|
|
let _e900: vec4<f32> = temporary3_;
|
|
let _e902: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e900.xxxx * _e902.yyyy).x;
|
|
let _e907: vec4<f32> = temporary0_;
|
|
let _e911: vec4<f32> = constant_registers[3u];
|
|
let _e913: vec4<f32> = (_e907.xyyy + _e911.xyyy);
|
|
temporary0_.x = _e913.x;
|
|
temporary0_.y = _e913.y;
|
|
let _e918: vec4<f32> = temporary0_;
|
|
let _e920: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e918.xyw, _e920.xyw);
|
|
let _e924: vec4<f32> = temporary2_;
|
|
let _e928: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e924.xxxx < _e928.wwww)).x;
|
|
let _e934: vec4<f32> = temporary1_;
|
|
let _e936: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e934.xxxx + _e936.xxxx).x;
|
|
let _e941: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e941.yyyy).x;
|
|
let _e948: vec4<f32> = constant_registers[0u];
|
|
let _e950: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e948.zzzz * _e950.xxxx).x;
|
|
let _e955: vec4<f32> = temporary0_;
|
|
let _e957: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e955.xyw, _e957.xzw);
|
|
let _e961: vec4<f32> = temporary3_;
|
|
let _e963: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e961.xxxx * _e963.yyyy).x;
|
|
let _e968: vec4<f32> = temporary0_;
|
|
let _e972: vec4<f32> = constant_registers[3u];
|
|
let _e974: vec4<f32> = (_e968.xyyy + _e972.xyyy);
|
|
temporary0_.x = _e974.x;
|
|
temporary0_.y = _e974.y;
|
|
let _e979: vec4<f32> = temporary0_;
|
|
let _e981: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e979.xyw, _e981.xyw);
|
|
let _e985: vec4<f32> = temporary2_;
|
|
let _e989: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e985.xxxx < _e989.wwww)).x;
|
|
let _e995: vec4<f32> = temporary1_;
|
|
let _e997: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e995.xxxx + _e997.xxxx).x;
|
|
let _e1002: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1002.yyyy).x;
|
|
let _e1009: vec4<f32> = constant_registers[0u];
|
|
let _e1011: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1009.zzzz * _e1011.xxxx).x;
|
|
let _e1016: vec4<f32> = temporary0_;
|
|
let _e1018: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1016.xyw, _e1018.xzw);
|
|
let _e1022: vec4<f32> = temporary3_;
|
|
let _e1024: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1022.xxxx * _e1024.yyyy).x;
|
|
let _e1029: vec4<f32> = temporary0_;
|
|
let _e1033: vec4<f32> = constant_registers[3u];
|
|
let _e1035: vec4<f32> = (_e1029.xyyy + _e1033.xyyy);
|
|
temporary0_.x = _e1035.x;
|
|
temporary0_.y = _e1035.y;
|
|
let _e1040: vec4<f32> = temporary0_;
|
|
let _e1042: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1040.xyw, _e1042.xyw);
|
|
let _e1046: vec4<f32> = temporary2_;
|
|
let _e1050: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1046.xxxx < _e1050.wwww)).x;
|
|
let _e1056: vec4<f32> = temporary1_;
|
|
let _e1058: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1056.xxxx + _e1058.xxxx).x;
|
|
let _e1063: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1063.yyyy).x;
|
|
let _e1070: vec4<f32> = constant_registers[0u];
|
|
let _e1072: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1070.zzzz * _e1072.xxxx).x;
|
|
let _e1077: vec4<f32> = temporary0_;
|
|
let _e1079: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1077.xyw, _e1079.xzw);
|
|
let _e1083: vec4<f32> = temporary3_;
|
|
let _e1085: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1083.xxxx * _e1085.yyyy).x;
|
|
let _e1090: vec4<f32> = temporary0_;
|
|
let _e1094: vec4<f32> = constant_registers[3u];
|
|
let _e1096: vec4<f32> = (_e1090.xyyy + _e1094.xyyy);
|
|
temporary0_.x = _e1096.x;
|
|
temporary0_.y = _e1096.y;
|
|
let _e1101: vec4<f32> = temporary0_;
|
|
let _e1103: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1101.xyw, _e1103.xyw);
|
|
let _e1107: vec4<f32> = temporary2_;
|
|
let _e1111: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1107.xxxx < _e1111.wwww)).x;
|
|
let _e1117: vec4<f32> = temporary1_;
|
|
let _e1119: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1117.xxxx + _e1119.xxxx).x;
|
|
let _e1124: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1124.yyyy).x;
|
|
let _e1131: vec4<f32> = constant_registers[0u];
|
|
let _e1133: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1131.zzzz * _e1133.xxxx).x;
|
|
let _e1138: vec4<f32> = temporary0_;
|
|
let _e1140: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1138.xyw, _e1140.xzw);
|
|
let _e1144: vec4<f32> = temporary3_;
|
|
let _e1146: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1144.xxxx * _e1146.yyyy).x;
|
|
let _e1151: vec4<f32> = temporary0_;
|
|
let _e1155: vec4<f32> = constant_registers[3u];
|
|
let _e1157: vec4<f32> = (_e1151.xyyy + _e1155.xyyy);
|
|
temporary0_.x = _e1157.x;
|
|
temporary0_.y = _e1157.y;
|
|
let _e1162: vec4<f32> = temporary0_;
|
|
let _e1164: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1162.xyw, _e1164.xyw);
|
|
let _e1168: vec4<f32> = temporary2_;
|
|
let _e1172: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1168.xxxx < _e1172.wwww)).x;
|
|
let _e1178: vec4<f32> = temporary1_;
|
|
let _e1180: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1178.xxxx + _e1180.xxxx).x;
|
|
let _e1185: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1185.yyyy).x;
|
|
let _e1192: vec4<f32> = constant_registers[0u];
|
|
let _e1194: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1192.zzzz * _e1194.xxxx).x;
|
|
let _e1199: vec4<f32> = temporary0_;
|
|
let _e1201: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1199.xyw, _e1201.xzw);
|
|
let _e1205: vec4<f32> = temporary3_;
|
|
let _e1207: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1205.xxxx * _e1207.yyyy).x;
|
|
let _e1212: vec4<f32> = temporary0_;
|
|
let _e1216: vec4<f32> = constant_registers[3u];
|
|
let _e1218: vec4<f32> = (_e1212.xyyy + _e1216.xyyy);
|
|
temporary0_.x = _e1218.x;
|
|
temporary0_.y = _e1218.y;
|
|
let _e1223: vec4<f32> = temporary0_;
|
|
let _e1225: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1223.xyw, _e1225.xyw);
|
|
let _e1229: vec4<f32> = temporary2_;
|
|
let _e1233: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1229.xxxx < _e1233.wwww)).x;
|
|
let _e1239: vec4<f32> = temporary1_;
|
|
let _e1241: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1239.xxxx + _e1241.xxxx).x;
|
|
let _e1246: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1246.yyyy).x;
|
|
let _e1253: vec4<f32> = constant_registers[0u];
|
|
let _e1255: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1253.zzzz * _e1255.xxxx).x;
|
|
let _e1260: vec4<f32> = temporary0_;
|
|
let _e1262: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1260.xyw, _e1262.xzw);
|
|
let _e1266: vec4<f32> = temporary3_;
|
|
let _e1268: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1266.xxxx * _e1268.yyyy).x;
|
|
let _e1273: vec4<f32> = temporary0_;
|
|
let _e1277: vec4<f32> = constant_registers[3u];
|
|
let _e1279: vec4<f32> = (_e1273.xyyy + _e1277.xyyy);
|
|
temporary0_.x = _e1279.x;
|
|
temporary0_.y = _e1279.y;
|
|
let _e1284: vec4<f32> = temporary0_;
|
|
let _e1286: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1284.xyw, _e1286.xyw);
|
|
let _e1290: vec4<f32> = temporary2_;
|
|
let _e1294: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1290.xxxx < _e1294.wwww)).x;
|
|
let _e1300: vec4<f32> = temporary1_;
|
|
let _e1302: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1300.xxxx + _e1302.xxxx).x;
|
|
let _e1307: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1307.yyyy).x;
|
|
let _e1314: vec4<f32> = constant_registers[0u];
|
|
let _e1316: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1314.zzzz * _e1316.xxxx).x;
|
|
let _e1321: vec4<f32> = temporary0_;
|
|
let _e1323: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1321.xyw, _e1323.xzw);
|
|
let _e1327: vec4<f32> = temporary3_;
|
|
let _e1329: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1327.xxxx * _e1329.yyyy).x;
|
|
let _e1334: vec4<f32> = temporary0_;
|
|
let _e1338: vec4<f32> = constant_registers[3u];
|
|
let _e1340: vec4<f32> = (_e1334.xyyy + _e1338.xyyy);
|
|
temporary0_.x = _e1340.x;
|
|
temporary0_.y = _e1340.y;
|
|
let _e1345: vec4<f32> = temporary0_;
|
|
let _e1347: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1345.xyw, _e1347.xyw);
|
|
let _e1351: vec4<f32> = temporary2_;
|
|
let _e1355: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1351.xxxx < _e1355.wwww)).x;
|
|
let _e1361: vec4<f32> = temporary1_;
|
|
let _e1363: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1361.xxxx + _e1363.xxxx).x;
|
|
let _e1368: vec4<f32> = temporary0_;
|
|
temporary0_.z = -(_e1368.yyyy).x;
|
|
let _e1375: vec4<f32> = constant_registers[0u];
|
|
let _e1377: vec4<f32> = temporary0_;
|
|
temporary3_.x = (_e1375.zzzz * _e1377.xxxx).x;
|
|
let _e1382: vec4<f32> = temporary0_;
|
|
let _e1384: vec4<f32> = temporary0_;
|
|
temporary0_.x = dot(_e1382.xyw, _e1384.xzw);
|
|
let _e1388: vec4<f32> = temporary3_;
|
|
let _e1390: vec4<f32> = temporary0_;
|
|
temporary0_.y = (_e1388.xxxx * _e1390.yyyy).x;
|
|
let _e1395: vec4<f32> = temporary0_;
|
|
let _e1399: vec4<f32> = constant_registers[3u];
|
|
let _e1401: vec4<f32> = (_e1395.xyyy + _e1399.xyyy);
|
|
temporary0_.x = _e1401.x;
|
|
temporary0_.y = _e1401.y;
|
|
let _e1406: vec4<f32> = temporary0_;
|
|
let _e1408: vec4<f32> = temporary0_;
|
|
temporary2_.x = dot(_e1406.xyw, _e1408.xyw);
|
|
let _e1412: vec4<f32> = temporary2_;
|
|
let _e1416: vec4<f32> = constant_registers[0u];
|
|
temporary3_.x = vec4<f32>((_e1412.xxxx < _e1416.wwww)).x;
|
|
let _e1422: vec4<f32> = temporary1_;
|
|
let _e1424: vec4<f32> = temporary3_;
|
|
temporary1_.x = (_e1422.xxxx + _e1424.xxxx).x;
|
|
let _e1429: vec4<f32> = temporary1_;
|
|
let _e1433: vec4<f32> = constant_registers[2u];
|
|
temporary2_.x = (_e1429.xxxx / _e1433.yyyy).x;
|
|
let _e1438: vec4<f32> = temporary2_;
|
|
let _e1442: vec4<f32> = constant_registers[1u];
|
|
temporary2_ = (_e1438.xxxx + _e1442);
|
|
let _e1444: vec4<f32> = temporary2_;
|
|
let _e1447: vec4<f32> = constant_registers[1u];
|
|
temporary2_ = (_e1444 + _e1447.wwww);
|
|
let _e1450: vec4<f32> = temporary2_;
|
|
let _e1453: vec4<f32> = constant_registers[0u];
|
|
temporary2_ = (_e1450 / _e1453.zzzz);
|
|
let _e1456: vec4<f32> = temporary2_;
|
|
temporary2_ = fract(_e1456);
|
|
let _e1458: vec4<f32> = temporary2_;
|
|
let _e1461: vec4<f32> = constant_registers[0u];
|
|
temporary2_ = (_e1458 * _e1461.zzzz);
|
|
let _e1464: vec4<f32> = temporary2_;
|
|
let _e1467: vec4<f32> = constant_registers[2u];
|
|
temporary2_ = (_e1464 - _e1467.zzzz);
|
|
let _e1470: vec4<f32> = temporary2_;
|
|
temporary2_ = abs(_e1470);
|
|
let _e1472: vec4<f32> = temporary1_;
|
|
let _e1476: vec4<f32> = constant_registers[2u];
|
|
temporary1_ = vec4<f32>((_e1472.xxxx < _e1476.yyyy));
|
|
let _e1480: vec4<f32> = temporary1_;
|
|
let _e1481: vec4<f32> = temporary2_;
|
|
dest_temp = (_e1480 * _e1481);
|
|
let _e1483: vec4<f32> = dest_temp;
|
|
return FragmentOutput(_e1483);
|
|
}
|
|
|