liangsheng8708
/
ruffle
mirror of https://mirror.ghproxy.com/https://github.com/ruffle-rs/ruffle.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

naga-agal: Add fractal shader test

This commit is contained in:
Mike Welsh 2023-04-03 17:10:49 -07:00
parent 83aff3c7ba
commit 7a6e6cf214
5 changed files with 706 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
render/naga-agal/tests/fractal_fragment.agal Normal file
View File

File diff suppressed because one or more lines are too long

2
render/naga-agal/tests/fractal_vertex.agal Normal file
View File

@ -0,0 +1,2 @@
// This is AGAL bytecode extracted from MolehillJulia.as
&[160,1,0,0,0,161,0,0,0,0,0,0,0,15,3,0,0,0,228,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,15,4,1,0,0,228,0,0,0,0,1,0,0,228,1,0,0,0,0,0,0,0,0,0,12,4,0,0,0,254,1,0,0,0,0,0,0,0,0,0,0,0]

643
render/naga-agal/tests/snapshots/wgsl__complex_fractal-2.snap Normal file
View File

@ -0,0 +1,643 @@
---
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>,28u>;
@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;
@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 _e7: vec4<f32> = param.xyyy;
temporary0_.x = _e7.x;
temporary0_.y = _e7.y;
let _e15: vec4<f32> = constant_registers[0u];
let _e16: vec4<f32> = _e15.xxxx;
temporary0_.z = _e16.z;
temporary0_.w = _e16.w;
let _e23: vec4<f32> = constant_registers[0u];
temporary1_.x = _e23.xxxx.x;
let _e28: vec4<f32> = temporary0_;
temporary0_.z = -(_e28.yyyy).x;
let _e35: vec4<f32> = constant_registers[0u];
let _e37: vec4<f32> = temporary0_;
temporary3_.x = (_e35.zzzz * _e37.xxxx).x;
let _e43: vec4<f32> = temporary0_;
let _e45: vec4<f32> = temporary0_;
temporary0_.x = dot(_e43.xyw, _e45.xzw);
let _e49: vec4<f32> = temporary3_;
let _e51: vec4<f32> = temporary0_;
temporary0_.y = (_e49.xxxx * _e51.yyyy).x;
let _e56: vec4<f32> = temporary0_;
let _e60: vec4<f32> = constant_registers[3u];
let _e62: vec4<f32> = (_e56.xyyy + _e60.xyyy);
temporary0_.x = _e62.x;
temporary0_.y = _e62.y;
let _e67: vec4<f32> = temporary0_;
let _e69: vec4<f32> = temporary0_;
temporary2_.x = dot(_e67.xyw, _e69.xyw);
let _e74: vec4<f32> = temporary2_;
let _e78: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e74.xxxx < _e78.wwww)).x;
let _e84: vec4<f32> = temporary1_;
let _e86: vec4<f32> = temporary3_;
temporary1_.x = (_e84.xxxx + _e86.xxxx).x;
let _e91: vec4<f32> = temporary0_;
temporary0_.z = -(_e91.yyyy).x;
let _e98: vec4<f32> = constant_registers[0u];
let _e100: vec4<f32> = temporary0_;
temporary3_.x = (_e98.zzzz * _e100.xxxx).x;
let _e105: vec4<f32> = temporary0_;
let _e107: vec4<f32> = temporary0_;
temporary0_.x = dot(_e105.xyw, _e107.xzw);
let _e111: vec4<f32> = temporary3_;
let _e113: vec4<f32> = temporary0_;
temporary0_.y = (_e111.xxxx * _e113.yyyy).x;
let _e118: vec4<f32> = temporary0_;
let _e122: vec4<f32> = constant_registers[3u];
let _e124: vec4<f32> = (_e118.xyyy + _e122.xyyy);
temporary0_.x = _e124.x;
temporary0_.y = _e124.y;
let _e129: vec4<f32> = temporary0_;
let _e131: vec4<f32> = temporary0_;
temporary2_.x = dot(_e129.xyw, _e131.xyw);
let _e135: vec4<f32> = temporary2_;
let _e139: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e135.xxxx < _e139.wwww)).x;
let _e145: vec4<f32> = temporary1_;
let _e147: vec4<f32> = temporary3_;
temporary1_.x = (_e145.xxxx + _e147.xxxx).x;
let _e152: vec4<f32> = temporary0_;
temporary0_.z = -(_e152.yyyy).x;
let _e159: vec4<f32> = constant_registers[0u];
let _e161: vec4<f32> = temporary0_;
temporary3_.x = (_e159.zzzz * _e161.xxxx).x;
let _e166: vec4<f32> = temporary0_;
let _e168: vec4<f32> = temporary0_;
temporary0_.x = dot(_e166.xyw, _e168.xzw);
let _e172: vec4<f32> = temporary3_;
let _e174: vec4<f32> = temporary0_;
temporary0_.y = (_e172.xxxx * _e174.yyyy).x;
let _e179: vec4<f32> = temporary0_;
let _e183: vec4<f32> = constant_registers[3u];
let _e185: vec4<f32> = (_e179.xyyy + _e183.xyyy);
temporary0_.x = _e185.x;
temporary0_.y = _e185.y;
let _e190: vec4<f32> = temporary0_;
let _e192: vec4<f32> = temporary0_;
temporary2_.x = dot(_e190.xyw, _e192.xyw);
let _e196: vec4<f32> = temporary2_;
let _e200: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e196.xxxx < _e200.wwww)).x;
let _e206: vec4<f32> = temporary1_;
let _e208: vec4<f32> = temporary3_;
temporary1_.x = (_e206.xxxx + _e208.xxxx).x;
let _e213: vec4<f32> = temporary0_;
temporary0_.z = -(_e213.yyyy).x;
let _e220: vec4<f32> = constant_registers[0u];
let _e222: vec4<f32> = temporary0_;
temporary3_.x = (_e220.zzzz * _e222.xxxx).x;
let _e227: vec4<f32> = temporary0_;
let _e229: vec4<f32> = temporary0_;
temporary0_.x = dot(_e227.xyw, _e229.xzw);
let _e233: vec4<f32> = temporary3_;
let _e235: vec4<f32> = temporary0_;
temporary0_.y = (_e233.xxxx * _e235.yyyy).x;
let _e240: vec4<f32> = temporary0_;
let _e244: vec4<f32> = constant_registers[3u];
let _e246: vec4<f32> = (_e240.xyyy + _e244.xyyy);
temporary0_.x = _e246.x;
temporary0_.y = _e246.y;
let _e251: vec4<f32> = temporary0_;
let _e253: vec4<f32> = temporary0_;
temporary2_.x = dot(_e251.xyw, _e253.xyw);
let _e257: vec4<f32> = temporary2_;
let _e261: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e257.xxxx < _e261.wwww)).x;
let _e267: vec4<f32> = temporary1_;
let _e269: vec4<f32> = temporary3_;
temporary1_.x = (_e267.xxxx + _e269.xxxx).x;
let _e274: vec4<f32> = temporary0_;
temporary0_.z = -(_e274.yyyy).x;
let _e281: vec4<f32> = constant_registers[0u];
let _e283: vec4<f32> = temporary0_;
temporary3_.x = (_e281.zzzz * _e283.xxxx).x;
let _e288: vec4<f32> = temporary0_;
let _e290: vec4<f32> = temporary0_;
temporary0_.x = dot(_e288.xyw, _e290.xzw);
let _e294: vec4<f32> = temporary3_;
let _e296: vec4<f32> = temporary0_;
temporary0_.y = (_e294.xxxx * _e296.yyyy).x;
let _e301: vec4<f32> = temporary0_;
let _e305: vec4<f32> = constant_registers[3u];
let _e307: vec4<f32> = (_e301.xyyy + _e305.xyyy);
temporary0_.x = _e307.x;
temporary0_.y = _e307.y;
let _e312: vec4<f32> = temporary0_;
let _e314: vec4<f32> = temporary0_;
temporary2_.x = dot(_e312.xyw, _e314.xyw);
let _e318: vec4<f32> = temporary2_;
let _e322: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e318.xxxx < _e322.wwww)).x;
let _e328: vec4<f32> = temporary1_;
let _e330: vec4<f32> = temporary3_;
temporary1_.x = (_e328.xxxx + _e330.xxxx).x;
let _e335: vec4<f32> = temporary0_;
temporary0_.z = -(_e335.yyyy).x;
let _e342: vec4<f32> = constant_registers[0u];
let _e344: vec4<f32> = temporary0_;
temporary3_.x = (_e342.zzzz * _e344.xxxx).x;
let _e349: vec4<f32> = temporary0_;
let _e351: vec4<f32> = temporary0_;
temporary0_.x = dot(_e349.xyw, _e351.xzw);
let _e355: vec4<f32> = temporary3_;
let _e357: vec4<f32> = temporary0_;
temporary0_.y = (_e355.xxxx * _e357.yyyy).x;
let _e362: vec4<f32> = temporary0_;
let _e366: vec4<f32> = constant_registers[3u];
let _e368: vec4<f32> = (_e362.xyyy + _e366.xyyy);
temporary0_.x = _e368.x;
temporary0_.y = _e368.y;
let _e373: vec4<f32> = temporary0_;
let _e375: vec4<f32> = temporary0_;
temporary2_.x = dot(_e373.xyw, _e375.xyw);
let _e379: vec4<f32> = temporary2_;
let _e383: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e379.xxxx < _e383.wwww)).x;
let _e389: vec4<f32> = temporary1_;
let _e391: vec4<f32> = temporary3_;
temporary1_.x = (_e389.xxxx + _e391.xxxx).x;
let _e396: vec4<f32> = temporary0_;
temporary0_.z = -(_e396.yyyy).x;
let _e403: vec4<f32> = constant_registers[0u];
let _e405: vec4<f32> = temporary0_;
temporary3_.x = (_e403.zzzz * _e405.xxxx).x;
let _e410: vec4<f32> = temporary0_;
let _e412: vec4<f32> = temporary0_;
temporary0_.x = dot(_e410.xyw, _e412.xzw);
let _e416: vec4<f32> = temporary3_;
let _e418: vec4<f32> = temporary0_;
temporary0_.y = (_e416.xxxx * _e418.yyyy).x;
let _e423: vec4<f32> = temporary0_;
let _e427: vec4<f32> = constant_registers[3u];
let _e429: vec4<f32> = (_e423.xyyy + _e427.xyyy);
temporary0_.x = _e429.x;
temporary0_.y = _e429.y;
let _e434: vec4<f32> = temporary0_;
let _e436: vec4<f32> = temporary0_;
temporary2_.x = dot(_e434.xyw, _e436.xyw);
let _e440: vec4<f32> = temporary2_;
let _e444: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e440.xxxx < _e444.wwww)).x;
let _e450: vec4<f32> = temporary1_;
let _e452: vec4<f32> = temporary3_;
temporary1_.x = (_e450.xxxx + _e452.xxxx).x;
let _e457: vec4<f32> = temporary0_;
temporary0_.z = -(_e457.yyyy).x;
let _e464: vec4<f32> = constant_registers[0u];
let _e466: vec4<f32> = temporary0_;
temporary3_.x = (_e464.zzzz * _e466.xxxx).x;
let _e471: vec4<f32> = temporary0_;
let _e473: vec4<f32> = temporary0_;
temporary0_.x = dot(_e471.xyw, _e473.xzw);
let _e477: vec4<f32> = temporary3_;
let _e479: vec4<f32> = temporary0_;
temporary0_.y = (_e477.xxxx * _e479.yyyy).x;
let _e484: vec4<f32> = temporary0_;
let _e488: vec4<f32> = constant_registers[3u];
let _e490: vec4<f32> = (_e484.xyyy + _e488.xyyy);
temporary0_.x = _e490.x;
temporary0_.y = _e490.y;
let _e495: vec4<f32> = temporary0_;
let _e497: vec4<f32> = temporary0_;
temporary2_.x = dot(_e495.xyw, _e497.xyw);
let _e501: vec4<f32> = temporary2_;
let _e505: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e501.xxxx < _e505.wwww)).x;
let _e511: vec4<f32> = temporary1_;
let _e513: vec4<f32> = temporary3_;
temporary1_.x = (_e511.xxxx + _e513.xxxx).x;
let _e518: vec4<f32> = temporary0_;
temporary0_.z = -(_e518.yyyy).x;
let _e525: vec4<f32> = constant_registers[0u];
let _e527: vec4<f32> = temporary0_;
temporary3_.x = (_e525.zzzz * _e527.xxxx).x;
let _e532: vec4<f32> = temporary0_;
let _e534: vec4<f32> = temporary0_;
temporary0_.x = dot(_e532.xyw, _e534.xzw);
let _e538: vec4<f32> = temporary3_;
let _e540: vec4<f32> = temporary0_;
temporary0_.y = (_e538.xxxx * _e540.yyyy).x;
let _e545: vec4<f32> = temporary0_;
let _e549: vec4<f32> = constant_registers[3u];
let _e551: vec4<f32> = (_e545.xyyy + _e549.xyyy);
temporary0_.x = _e551.x;
temporary0_.y = _e551.y;
let _e556: vec4<f32> = temporary0_;
let _e558: vec4<f32> = temporary0_;
temporary2_.x = dot(_e556.xyw, _e558.xyw);
let _e562: vec4<f32> = temporary2_;
let _e566: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e562.xxxx < _e566.wwww)).x;
let _e572: vec4<f32> = temporary1_;
let _e574: vec4<f32> = temporary3_;
temporary1_.x = (_e572.xxxx + _e574.xxxx).x;
let _e579: vec4<f32> = temporary0_;
temporary0_.z = -(_e579.yyyy).x;
let _e586: vec4<f32> = constant_registers[0u];
let _e588: vec4<f32> = temporary0_;
temporary3_.x = (_e586.zzzz * _e588.xxxx).x;
let _e593: vec4<f32> = temporary0_;
let _e595: vec4<f32> = temporary0_;
temporary0_.x = dot(_e593.xyw, _e595.xzw);
let _e599: vec4<f32> = temporary3_;
let _e601: vec4<f32> = temporary0_;
temporary0_.y = (_e599.xxxx * _e601.yyyy).x;
let _e606: vec4<f32> = temporary0_;
let _e610: vec4<f32> = constant_registers[3u];
let _e612: vec4<f32> = (_e606.xyyy + _e610.xyyy);
temporary0_.x = _e612.x;
temporary0_.y = _e612.y;
let _e617: vec4<f32> = temporary0_;
let _e619: vec4<f32> = temporary0_;
temporary2_.x = dot(_e617.xyw, _e619.xyw);
let _e623: vec4<f32> = temporary2_;
let _e627: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e623.xxxx < _e627.wwww)).x;
let _e633: vec4<f32> = temporary1_;
let _e635: vec4<f32> = temporary3_;
temporary1_.x = (_e633.xxxx + _e635.xxxx).x;
let _e640: vec4<f32> = temporary0_;
temporary0_.z = -(_e640.yyyy).x;
let _e647: vec4<f32> = constant_registers[0u];
let _e649: vec4<f32> = temporary0_;
temporary3_.x = (_e647.zzzz * _e649.xxxx).x;
let _e654: vec4<f32> = temporary0_;
let _e656: vec4<f32> = temporary0_;
temporary0_.x = dot(_e654.xyw, _e656.xzw);
let _e660: vec4<f32> = temporary3_;
let _e662: vec4<f32> = temporary0_;
temporary0_.y = (_e660.xxxx * _e662.yyyy).x;
let _e667: vec4<f32> = temporary0_;
let _e671: vec4<f32> = constant_registers[3u];
let _e673: vec4<f32> = (_e667.xyyy + _e671.xyyy);
temporary0_.x = _e673.x;
temporary0_.y = _e673.y;
let _e678: vec4<f32> = temporary0_;
let _e680: vec4<f32> = temporary0_;
temporary2_.x = dot(_e678.xyw, _e680.xyw);
let _e684: vec4<f32> = temporary2_;
let _e688: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e684.xxxx < _e688.wwww)).x;
let _e694: vec4<f32> = temporary1_;
let _e696: vec4<f32> = temporary3_;
temporary1_.x = (_e694.xxxx + _e696.xxxx).x;
let _e701: vec4<f32> = temporary0_;
temporary0_.z = -(_e701.yyyy).x;
let _e708: vec4<f32> = constant_registers[0u];
let _e710: vec4<f32> = temporary0_;
temporary3_.x = (_e708.zzzz * _e710.xxxx).x;
let _e715: vec4<f32> = temporary0_;
let _e717: vec4<f32> = temporary0_;
temporary0_.x = dot(_e715.xyw, _e717.xzw);
let _e721: vec4<f32> = temporary3_;
let _e723: vec4<f32> = temporary0_;
temporary0_.y = (_e721.xxxx * _e723.yyyy).x;
let _e728: vec4<f32> = temporary0_;
let _e732: vec4<f32> = constant_registers[3u];
let _e734: vec4<f32> = (_e728.xyyy + _e732.xyyy);
temporary0_.x = _e734.x;
temporary0_.y = _e734.y;
let _e739: vec4<f32> = temporary0_;
let _e741: vec4<f32> = temporary0_;
temporary2_.x = dot(_e739.xyw, _e741.xyw);
let _e745: vec4<f32> = temporary2_;
let _e749: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e745.xxxx < _e749.wwww)).x;
let _e755: vec4<f32> = temporary1_;
let _e757: vec4<f32> = temporary3_;
temporary1_.x = (_e755.xxxx + _e757.xxxx).x;
let _e762: vec4<f32> = temporary0_;
temporary0_.z = -(_e762.yyyy).x;
let _e769: vec4<f32> = constant_registers[0u];
let _e771: vec4<f32> = temporary0_;
temporary3_.x = (_e769.zzzz * _e771.xxxx).x;
let _e776: vec4<f32> = temporary0_;
let _e778: vec4<f32> = temporary0_;
temporary0_.x = dot(_e776.xyw, _e778.xzw);
let _e782: vec4<f32> = temporary3_;
let _e784: vec4<f32> = temporary0_;
temporary0_.y = (_e782.xxxx * _e784.yyyy).x;
let _e789: vec4<f32> = temporary0_;
let _e793: vec4<f32> = constant_registers[3u];
let _e795: vec4<f32> = (_e789.xyyy + _e793.xyyy);
temporary0_.x = _e795.x;
temporary0_.y = _e795.y;
let _e800: vec4<f32> = temporary0_;
let _e802: vec4<f32> = temporary0_;
temporary2_.x = dot(_e800.xyw, _e802.xyw);
let _e806: vec4<f32> = temporary2_;
let _e810: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e806.xxxx < _e810.wwww)).x;
let _e816: vec4<f32> = temporary1_;
let _e818: vec4<f32> = temporary3_;
temporary1_.x = (_e816.xxxx + _e818.xxxx).x;
let _e823: vec4<f32> = temporary0_;
temporary0_.z = -(_e823.yyyy).x;
let _e830: vec4<f32> = constant_registers[0u];
let _e832: vec4<f32> = temporary0_;
temporary3_.x = (_e830.zzzz * _e832.xxxx).x;
let _e837: vec4<f32> = temporary0_;
let _e839: vec4<f32> = temporary0_;
temporary0_.x = dot(_e837.xyw, _e839.xzw);
let _e843: vec4<f32> = temporary3_;
let _e845: vec4<f32> = temporary0_;
temporary0_.y = (_e843.xxxx * _e845.yyyy).x;
let _e850: vec4<f32> = temporary0_;
let _e854: vec4<f32> = constant_registers[3u];
let _e856: vec4<f32> = (_e850.xyyy + _e854.xyyy);
temporary0_.x = _e856.x;
temporary0_.y = _e856.y;
let _e861: vec4<f32> = temporary0_;
let _e863: vec4<f32> = temporary0_;
temporary2_.x = dot(_e861.xyw, _e863.xyw);
let _e867: vec4<f32> = temporary2_;
let _e871: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e867.xxxx < _e871.wwww)).x;
let _e877: vec4<f32> = temporary1_;
let _e879: vec4<f32> = temporary3_;
temporary1_.x = (_e877.xxxx + _e879.xxxx).x;
let _e884: vec4<f32> = temporary0_;
temporary0_.z = -(_e884.yyyy).x;
let _e891: vec4<f32> = constant_registers[0u];
let _e893: vec4<f32> = temporary0_;
temporary3_.x = (_e891.zzzz * _e893.xxxx).x;
let _e898: vec4<f32> = temporary0_;
let _e900: vec4<f32> = temporary0_;
temporary0_.x = dot(_e898.xyw, _e900.xzw);
let _e904: vec4<f32> = temporary3_;
let _e906: vec4<f32> = temporary0_;
temporary0_.y = (_e904.xxxx * _e906.yyyy).x;
let _e911: vec4<f32> = temporary0_;
let _e915: vec4<f32> = constant_registers[3u];
let _e917: vec4<f32> = (_e911.xyyy + _e915.xyyy);
temporary0_.x = _e917.x;
temporary0_.y = _e917.y;
let _e922: vec4<f32> = temporary0_;
let _e924: vec4<f32> = temporary0_;
temporary2_.x = dot(_e922.xyw, _e924.xyw);
let _e928: vec4<f32> = temporary2_;
let _e932: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e928.xxxx < _e932.wwww)).x;
let _e938: vec4<f32> = temporary1_;
let _e940: vec4<f32> = temporary3_;
temporary1_.x = (_e938.xxxx + _e940.xxxx).x;
let _e945: vec4<f32> = temporary0_;
temporary0_.z = -(_e945.yyyy).x;
let _e952: vec4<f32> = constant_registers[0u];
let _e954: vec4<f32> = temporary0_;
temporary3_.x = (_e952.zzzz * _e954.xxxx).x;
let _e959: vec4<f32> = temporary0_;
let _e961: vec4<f32> = temporary0_;
temporary0_.x = dot(_e959.xyw, _e961.xzw);
let _e965: vec4<f32> = temporary3_;
let _e967: vec4<f32> = temporary0_;
temporary0_.y = (_e965.xxxx * _e967.yyyy).x;
let _e972: vec4<f32> = temporary0_;
let _e976: vec4<f32> = constant_registers[3u];
let _e978: vec4<f32> = (_e972.xyyy + _e976.xyyy);
temporary0_.x = _e978.x;
temporary0_.y = _e978.y;
let _e983: vec4<f32> = temporary0_;
let _e985: vec4<f32> = temporary0_;
temporary2_.x = dot(_e983.xyw, _e985.xyw);
let _e989: vec4<f32> = temporary2_;
let _e993: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e989.xxxx < _e993.wwww)).x;
let _e999: vec4<f32> = temporary1_;
let _e1001: vec4<f32> = temporary3_;
temporary1_.x = (_e999.xxxx + _e1001.xxxx).x;
let _e1006: vec4<f32> = temporary0_;
temporary0_.z = -(_e1006.yyyy).x;
let _e1013: vec4<f32> = constant_registers[0u];
let _e1015: vec4<f32> = temporary0_;
temporary3_.x = (_e1013.zzzz * _e1015.xxxx).x;
let _e1020: vec4<f32> = temporary0_;
let _e1022: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1020.xyw, _e1022.xzw);
let _e1026: vec4<f32> = temporary3_;
let _e1028: vec4<f32> = temporary0_;
temporary0_.y = (_e1026.xxxx * _e1028.yyyy).x;
let _e1033: vec4<f32> = temporary0_;
let _e1037: vec4<f32> = constant_registers[3u];
let _e1039: vec4<f32> = (_e1033.xyyy + _e1037.xyyy);
temporary0_.x = _e1039.x;
temporary0_.y = _e1039.y;
let _e1044: vec4<f32> = temporary0_;
let _e1046: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1044.xyw, _e1046.xyw);
let _e1050: vec4<f32> = temporary2_;
let _e1054: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1050.xxxx < _e1054.wwww)).x;
let _e1060: vec4<f32> = temporary1_;
let _e1062: vec4<f32> = temporary3_;
temporary1_.x = (_e1060.xxxx + _e1062.xxxx).x;
let _e1067: vec4<f32> = temporary0_;
temporary0_.z = -(_e1067.yyyy).x;
let _e1074: vec4<f32> = constant_registers[0u];
let _e1076: vec4<f32> = temporary0_;
temporary3_.x = (_e1074.zzzz * _e1076.xxxx).x;
let _e1081: vec4<f32> = temporary0_;
let _e1083: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1081.xyw, _e1083.xzw);
let _e1087: vec4<f32> = temporary3_;
let _e1089: vec4<f32> = temporary0_;
temporary0_.y = (_e1087.xxxx * _e1089.yyyy).x;
let _e1094: vec4<f32> = temporary0_;
let _e1098: vec4<f32> = constant_registers[3u];
let _e1100: vec4<f32> = (_e1094.xyyy + _e1098.xyyy);
temporary0_.x = _e1100.x;
temporary0_.y = _e1100.y;
let _e1105: vec4<f32> = temporary0_;
let _e1107: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1105.xyw, _e1107.xyw);
let _e1111: vec4<f32> = temporary2_;
let _e1115: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1111.xxxx < _e1115.wwww)).x;
let _e1121: vec4<f32> = temporary1_;
let _e1123: vec4<f32> = temporary3_;
temporary1_.x = (_e1121.xxxx + _e1123.xxxx).x;
let _e1128: vec4<f32> = temporary0_;
temporary0_.z = -(_e1128.yyyy).x;
let _e1135: vec4<f32> = constant_registers[0u];
let _e1137: vec4<f32> = temporary0_;
temporary3_.x = (_e1135.zzzz * _e1137.xxxx).x;
let _e1142: vec4<f32> = temporary0_;
let _e1144: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1142.xyw, _e1144.xzw);
let _e1148: vec4<f32> = temporary3_;
let _e1150: vec4<f32> = temporary0_;
temporary0_.y = (_e1148.xxxx * _e1150.yyyy).x;
let _e1155: vec4<f32> = temporary0_;
let _e1159: vec4<f32> = constant_registers[3u];
let _e1161: vec4<f32> = (_e1155.xyyy + _e1159.xyyy);
temporary0_.x = _e1161.x;
temporary0_.y = _e1161.y;
let _e1166: vec4<f32> = temporary0_;
let _e1168: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1166.xyw, _e1168.xyw);
let _e1172: vec4<f32> = temporary2_;
let _e1176: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1172.xxxx < _e1176.wwww)).x;
let _e1182: vec4<f32> = temporary1_;
let _e1184: vec4<f32> = temporary3_;
temporary1_.x = (_e1182.xxxx + _e1184.xxxx).x;
let _e1189: vec4<f32> = temporary0_;
temporary0_.z = -(_e1189.yyyy).x;
let _e1196: vec4<f32> = constant_registers[0u];
let _e1198: vec4<f32> = temporary0_;
temporary3_.x = (_e1196.zzzz * _e1198.xxxx).x;
let _e1203: vec4<f32> = temporary0_;
let _e1205: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1203.xyw, _e1205.xzw);
let _e1209: vec4<f32> = temporary3_;
let _e1211: vec4<f32> = temporary0_;
temporary0_.y = (_e1209.xxxx * _e1211.yyyy).x;
let _e1216: vec4<f32> = temporary0_;
let _e1220: vec4<f32> = constant_registers[3u];
let _e1222: vec4<f32> = (_e1216.xyyy + _e1220.xyyy);
temporary0_.x = _e1222.x;
temporary0_.y = _e1222.y;
let _e1227: vec4<f32> = temporary0_;
let _e1229: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1227.xyw, _e1229.xyw);
let _e1233: vec4<f32> = temporary2_;
let _e1237: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1233.xxxx < _e1237.wwww)).x;
let _e1243: vec4<f32> = temporary1_;
let _e1245: vec4<f32> = temporary3_;
temporary1_.x = (_e1243.xxxx + _e1245.xxxx).x;
let _e1250: vec4<f32> = temporary0_;
temporary0_.z = -(_e1250.yyyy).x;
let _e1257: vec4<f32> = constant_registers[0u];
let _e1259: vec4<f32> = temporary0_;
temporary3_.x = (_e1257.zzzz * _e1259.xxxx).x;
let _e1264: vec4<f32> = temporary0_;
let _e1266: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1264.xyw, _e1266.xzw);
let _e1270: vec4<f32> = temporary3_;
let _e1272: vec4<f32> = temporary0_;
temporary0_.y = (_e1270.xxxx * _e1272.yyyy).x;
let _e1277: vec4<f32> = temporary0_;
let _e1281: vec4<f32> = constant_registers[3u];
let _e1283: vec4<f32> = (_e1277.xyyy + _e1281.xyyy);
temporary0_.x = _e1283.x;
temporary0_.y = _e1283.y;
let _e1288: vec4<f32> = temporary0_;
let _e1290: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1288.xyw, _e1290.xyw);
let _e1294: vec4<f32> = temporary2_;
let _e1298: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1294.xxxx < _e1298.wwww)).x;
let _e1304: vec4<f32> = temporary1_;
let _e1306: vec4<f32> = temporary3_;
temporary1_.x = (_e1304.xxxx + _e1306.xxxx).x;
let _e1311: vec4<f32> = temporary0_;
temporary0_.z = -(_e1311.yyyy).x;
let _e1318: vec4<f32> = constant_registers[0u];
let _e1320: vec4<f32> = temporary0_;
temporary3_.x = (_e1318.zzzz * _e1320.xxxx).x;
let _e1325: vec4<f32> = temporary0_;
let _e1327: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1325.xyw, _e1327.xzw);
let _e1331: vec4<f32> = temporary3_;
let _e1333: vec4<f32> = temporary0_;
temporary0_.y = (_e1331.xxxx * _e1333.yyyy).x;
let _e1338: vec4<f32> = temporary0_;
let _e1342: vec4<f32> = constant_registers[3u];
let _e1344: vec4<f32> = (_e1338.xyyy + _e1342.xyyy);
temporary0_.x = _e1344.x;
temporary0_.y = _e1344.y;
let _e1349: vec4<f32> = temporary0_;
let _e1351: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1349.xyw, _e1351.xyw);
let _e1355: vec4<f32> = temporary2_;
let _e1359: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1355.xxxx < _e1359.wwww)).x;
let _e1365: vec4<f32> = temporary1_;
let _e1367: vec4<f32> = temporary3_;
temporary1_.x = (_e1365.xxxx + _e1367.xxxx).x;
let _e1372: vec4<f32> = temporary0_;
temporary0_.z = -(_e1372.yyyy).x;
let _e1379: vec4<f32> = constant_registers[0u];
let _e1381: vec4<f32> = temporary0_;
temporary3_.x = (_e1379.zzzz * _e1381.xxxx).x;
let _e1386: vec4<f32> = temporary0_;
let _e1388: vec4<f32> = temporary0_;
temporary0_.x = dot(_e1386.xyw, _e1388.xzw);
let _e1392: vec4<f32> = temporary3_;
let _e1394: vec4<f32> = temporary0_;
temporary0_.y = (_e1392.xxxx * _e1394.yyyy).x;
let _e1399: vec4<f32> = temporary0_;
let _e1403: vec4<f32> = constant_registers[3u];
let _e1405: vec4<f32> = (_e1399.xyyy + _e1403.xyyy);
temporary0_.x = _e1405.x;
temporary0_.y = _e1405.y;
let _e1410: vec4<f32> = temporary0_;
let _e1412: vec4<f32> = temporary0_;
temporary2_.x = dot(_e1410.xyw, _e1412.xyw);
let _e1416: vec4<f32> = temporary2_;
let _e1420: vec4<f32> = constant_registers[0u];
temporary3_.x = vec4<f32>((_e1416.xxxx < _e1420.wwww)).x;
let _e1426: vec4<f32> = temporary1_;
let _e1428: vec4<f32> = temporary3_;
temporary1_.x = (_e1426.xxxx + _e1428.xxxx).x;
let _e1433: vec4<f32> = temporary1_;
let _e1437: vec4<f32> = constant_registers[2u];
temporary2_.x = (_e1433.xxxx / _e1437.yyyy).x;
let _e1442: vec4<f32> = temporary2_;
let _e1446: vec4<f32> = constant_registers[1u];
temporary2_ = (_e1442.xxxx + _e1446);
let _e1448: vec4<f32> = temporary2_;
let _e1451: vec4<f32> = constant_registers[1u];
temporary2_ = (_e1448 + _e1451.wwww);
let _e1454: vec4<f32> = temporary2_;
let _e1457: vec4<f32> = constant_registers[0u];
temporary2_ = (_e1454 / _e1457.zzzz);
let _e1460: vec4<f32> = temporary2_;
temporary2_ = fract(_e1460);
let _e1462: vec4<f32> = temporary2_;
let _e1465: vec4<f32> = constant_registers[0u];
temporary2_ = (_e1462 * _e1465.zzzz);
let _e1468: vec4<f32> = temporary2_;
let _e1471: vec4<f32> = constant_registers[2u];
temporary2_ = (_e1468 - _e1471.zzzz);
let _e1474: vec4<f32> = temporary2_;
temporary2_ = abs(_e1474);
let _e1476: vec4<f32> = temporary1_;
let _e1480: vec4<f32> = constant_registers[2u];
temporary1_ = vec4<f32>((_e1476.xxxx < _e1480.yyyy));
let _e1484: vec4<f32> = temporary1_;
let _e1485: vec4<f32> = temporary2_;
dest_temp = (_e1484 * _e1485);
let _e1487: vec4<f32> = dest_temp;
return FragmentOutput(_e1487);
}

32
render/naga-agal/tests/snapshots/wgsl__complex_fractal.snap Normal file
View File

@ -0,0 +1,32 @@
---
source: render/naga-agal/tests/wgsl.rs
expression: output
---
struct VertexOutput {
@builtin(position) member: vec4<f32>,
@location(0) varying_0_: vec4<f32>,
}
@group(0) @binding(0)
var<uniform> constant_registers: array<vec4<f32>,128u>;
@vertex
fn main(@location(0) param: vec2<f32>, @location(1) param_1: vec2<f32>) -> VertexOutput {
var dest_temp: vec4<f32>;
var varying_0_: vec4<f32>;
dest_temp = vec4<f32>(param.x, param.y, 0.0, 1.0);
let _e10: vec4<f32> = constant_registers[1u];
let _e13: vec4<f32> = constant_registers[2u];
let _e16: vec4<f32> = constant_registers[3u];
let _e19: vec4<f32> = constant_registers[4u];
varying_0_ = (transpose(mat4x4<f32>(_e10, _e13, _e16, _e19)) * vec4<f32>(param_1.x, param_1.y, 0.0, 1.0));
let _e32: vec4<f32> = constant_registers[0u];
let _e33: vec4<f32> = _e32.zwww;
varying_0_.z = _e33.z;
varying_0_.w = _e33.w;
let _e38: vec4<f32> = dest_temp;
let _e39: vec4<f32> = varying_0_;
return VertexOutput(_e38, _e39);
}

27
render/naga-agal/tests/wgsl.rs
View File

@ -108,3 +108,30 @@ fn test_complex_raytrace() {
ShaderType::Fragment
);
}
#[test]
fn test_complex_fractal() {
const FRACTAL_VERTEX: &[u8] = include!("fractal_vertex.agal");
const FRACTAL_FRAGMENT: &[u8] = include!("fractal_fragment.agal");
test_shader!(
FRACTAL_VERTEX,
&[
Some(VertexAttributeFormat::Float2),
Some(VertexAttributeFormat::Float2),
None,
None,
None,
None,
None,
None
],
ShaderType::Vertex
);
test_shader!(
FRACTAL_FRAGMENT,
&[None, None, None, None, None, None, None, None],
ShaderType::Fragment
);
}