https://patron.theateralliance.org/_next/static/chunks/9473.05505d270278c94b.js

1"use strict";(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[9473],{9473:(e,r,t)=>{t.r(r),t.d(r,{arithmetic:()=>l,dot:()=>f,equalAll:()=>c,extent:()=>_,fround:()=>P,gather:()=>T,interleave:()=>L.C,length:()=>z,segmentedMap:()=>b,select:()=>C,sequence:()=>N,swizzle:()=>B});var n=t(79265),i=t(33386),u=t(24706),a=t(2897),s=t(45044);let o=`fn arithmetic_add(x: {TYPE}, y: {TYPE}) -> {TYPE} {
2  return x + y;
3}
4
5fn arithmetic_subtract(x: {TYPE}, y: {TYPE}) -> {TYPE} {
6  return x - y;
7}
8
9fn arithmetic_multiply(x: {TYPE}, y: {TYPE}) -> {TYPE} {
10  return x * y;
11}
12
13fn arithmetic_divide(x: {TYPE}, y: {TYPE}) -> {TYPE} {
14  return x / y;
15}
16
17fn arithmetic_tan(x: f32) -> f32 {
18  return tan_fp32(x);
19}
20`,l=({inputs:e,output:r,target:t})=>{let l=r.type,d=(0,s.iP)(l),f=(0,s._1)(l),p=e.namedInputs;return(0,a.P)({module:{name:"arithmetic",source:o,dependencies:[n.i]},inputs:p,output:r,operationType:l,outputBuffer:t,expression:r=>(0,i.W)(e.expression,{operations:u.E,inputs:p,laneIndex:r,formatInput:e=>`${e}[${r}]`,formatOutOfBoundsInput:e=>1===p[e].size?`${e}[0]`:f,formatLiteral:e=>{let t=Array.isArray(e)?e[r]??0:e;return`${d}(${(0,s.C1)(l,t)})`},formatCall:(e,r)=>`${e}(${r.join(", ")})`})}),{success:!0}},d=`\
21fn row_dot(x: array<{TYPE}, {X_LEN}>, y: array<{TYPE}, {Y_LEN}>) -> array<f32, 1> {
22  var sum = 0.0;
23  for (var i = 0u; i < {X_LEN}u; i = i + 1u) {
24    sum += f32(x[i]) * f32(y[i]);
25  }
26  return array<f32, 1>(sum);
27}
28`,f=({inputs:e,output:r,target:t})=>((0,a.P)({module:{name:"row_dot",source:d},inputs:e,output:r,operationType:"float32",outputBuffer:t}),{success:!0}),p=`\
29fn equalAll(x: array<{TYPE}, {X_LEN}>, y: array<{TYPE}, {Y_LEN}>) -> array<u32, 1> {
30  var allEqual = 1u;
31  for (var i = 0u; i < {X_LEN}u; i = i + 1u) {
32    if (x[i] != y[i]) {
33      allEqual = 0u;
34      break;
35    }
36  }
37  return array<u32, 1>(allEqual);
38}
39`,c=({inputs:e,output:r,target:t})=>((0,a.P)({module:{name:"equalAll",source:p},inputs:e,output:r,operationType:e.x.type,outputBuffer:t}),{success:!0});var x=t(38705),g=t(53733),m=t(95871),h=t(81870);function $(e,r,t){let n=(0,s.iP)(r.type);return`@group(0) @binding(${t}) var<storage, read> ${e}: array<${n}>;`}function y(e,r,t,n=e){let i=(0,s.iP)(t);if(r.isConstant){let e=r.value;if(!e)throw Error(`Constant input ${r} is missing CPU values`);return`fn read_${n}(_sourceIndex: u32) -> array<${i}, ${r.size}> {
40  return array<${i}, ${r.size}>(${Array.from({length:r.size},(r,t)=>(0,s.Lm)(i,e[t]??0)).join(", ")});
41}`}let u=r.stride/r.ValueType.BYTES_PER_ELEMENT,a=r.offset/r.ValueType.BYTES_PER_ELEMENT,o=(0,s.iP)(r.type)===i?"":`${i}`;return`fn read_${n}(sourceIndex: u32) -> array<${i}, ${r.size}> {
42  var value: array<${i}, ${r.size}>;
43  let rowOffset = ${a}u + sourceIndex * ${u}u;
44${Array.from({length:r.size},(r,t)=>o?`  value[${t}] = ${o}(${e}[rowOffset + ${t}u]);`:`  value[${t}] = ${e}[rowOffset + ${t}u];`).join("\n")}
45  return value;
46}`}function w(e,r){return y("sourceValues",e,r,"source_values")}function v(e,r){let t=(0,s.iP)(e.type);return`@group(0) @binding(${r}) var<storage, read_write> result: array<${t}>;`}function E(e){let r=e.stride/e.ValueType.BYTES_PER_ELEMENT,t=e.offset/e.ValueType.BYTES_PER_ELEMENT,n=(0,s.iP)(e.type);return`fn write_result(rowIndex: u32, value: array<${n}, ${e.size}>) {
47  let rowOffset = ${t}u + rowIndex * ${r}u;
48${Array.from({length:e.size},(e,r)=>`  result[rowOffset + ${r}u] = value[${r}];`).join("\n")}
49}`}let _=({inputs:e,output:r,target:t})=>{let{sourceValues:n}=e;if(0===n.length){let e=new r.ValueType(r.length*r.size);return t.write(e),{success:!0,value:e}}if(n.isConstant){let e=n.value;if(!e)throw Error(`Constant input ${n} is missing CPU values`);let i=new r.ValueType(r.length*r.size);for(let t=0;t<r.length;t++){let r=e[t];i[2*t]=r,i[2*t+1]=r}return t.write(i),{success:!0,value:i}}let i=[],u=n,a="raw",o=n.length;try{for(;;){let e=Math.ceil(o/64),n=r.length*e,l=1===e?t:m.R.createOrReuse(t.device,n*r.stride);if(e>1&&i.push(l),function({input:e,inputMode:r,inputGroupCount:t,channelCount:n,outputType:i,outputBuffer:u,outputLength:a,outputStride:o,outputOffset:l}){let d=(0,s.iP)(i),f=(0,h.BB)(a,u.device.limits.maxComputeWorkgroupsPerDimension),p=new g.GL({buffer:u,type:i,size:2,length:a,stride:o,offset:l}),c=`
50${e.isConstant?"":$("sourceValues",e,0)}
51${w(e,i)}
52${v(p,+!e.isConstant)}
53${E(p)}
54${function(e,r,t,n){let i=(0,s.iP)(r),[u,a]=function(e){switch(e){case"uint32":return["0xffffffffu","0u"];case"sint32":return["2147483647","-2147483648"];case"float32":return["3.402823e38","-3.402823e38"];default:throw Error(`Unsupported WebGPU extent type for ${e}`)}}(r);return"raw"===e?`fn extent_pass(channelIndex: u32, inputGroupIndex: u32) -> array<${i}, 2> {
55  var result: array<${i}, 2>;
56  result[0] = ${u};
57  result[1] = ${a};
58
59  if (inputGroupIndex < ${n}u) {

60    let value = read_source_values(inputGroupIndex);
61    result[0] = value[channelIndex];
62    result[1] = value[channelIndex];
63  }
64
65  return result;
66}`:`fn extent_pass(channelIndex: u32, inputGroupIndex: u32) -> array<${i}, 2> {
67  var result: array<${i}, 2>;
68  result[0] = ${u};
69  result[1] = ${a};
70
71  if (inputGroupIndex < ${n}u) {
72    let rowIndex = inputGroupIndex * ${t}u + channelIndex;
73    let value = read_source_values(rowIndex);
74    result[0] = value[0];
75    result[1] = value[1];
76  }
77
78  return result;
79}`}(r,i,n,t)}
80
81var<workgroup> sharedMin: array<${d}, 64>;
82var<workgroup> sharedMax: array<${d}, 64>;
83
84@compute @workgroup_size(64) fn main(
85  @builtin(workgroup_id) workgroupId: vec3<u32>,
86  @builtin(local_invocation_id) localId: vec3<u32>
87) {
88  let outputRowIndex = ${(0,h.B)(f)};
89  if (outputRowIndex >= ${a}u) {
90    return;
91  }
92
93  let channelIndex = outputRowIndex % ${n}u;
94  let outputGroupIndex = outputRowIndex / ${n}u;
95  let inputGroupIndex = outputGroupIndex * 64u + localId.x;
96
97  let result = extent_pass(channelIndex, inputGroupIndex);
98  sharedMin[localId.x] = result[0];
99  sharedMax[localId.x] = result[1];
100  workgroupBarrier();
101
102  var stride = ${Math.floor(32)}u;
103  loop {
104    if (stride == 0u) {
105      break;
106    }
107    if (localId.x < stride) {
108      let compareIndex = localId.x + stride;
109      if (sharedMin[compareIndex] < sharedMin[localId.x]) {
110        sharedMin[localId.x] = sharedMin[compareIndex];
111      }
112      if (sharedMax[compareIndex] > sharedMax[localId.x]) {
113        sharedMax[localId.x] = sharedMax[compareIndex];
114      }
115    }
116    workgroupBarrier();
117    stride = stride / 2u;
118  }
119
120  if (localId.x == 0u) {
121    write_result(outputRowIndex, array<${d}, 2>(sharedMin[0], sharedMax[0]));
122  }
123}
124`,m=new x.C(u.device,{source:c,shaderLayout:{bindings:[...e.isConstant?[]:[{name:"sourceValues",type:"storage",group:0,location:0}],{name:"result",type:"storage",group:0,location:+!e.isConstant}]}}),y={result:u};e.isConstant||(y.sourceValues=e.buffer),m.setBindings(y);let _=u.device.beginComputePass({});m.dispatch(_,f.x,f.y,f.z),_.end(),u.device.submit(),m.destroy()}({input:u,inputMode:a,inputGroupCount:o,channelCount:r.length,outputType:r.type,outputBuffer:l,outputLength:n,outputStride:r.stride,outputOffset:r.offset}),1===e)break;u=new g.GL({buffer:l,type:r.type,size:2,length:n}),a="partial",o=e}return{success:!0}}finally{for(let e of i)m.R.recycle(e)}},I=`\
125const LE: bool = ${new Uint8Array(new Uint16Array([255]).buffer)[0]>0?"true":"false"};
126const F32_NAN: u32 = 0xffffffffu;
127const F32_INF: u32 = 0x7f800000u;
128
129fn roundShiftRight(value: u32, shift: i32) -> u32 {
130  if (shift <= 0) {
131    return value << u32(-shift);
132  }
133
134  if (shift >= 32) {
135    if (shift == 32 && value > 0x80000000u) {
136      return 1u;
137    }
138    return 0u;
139  }
140
141  let shiftU32 = u32(shift);
142  let truncated = value >> shiftU32;
143  let halfShift = 1u << u32(shift - 1);
144  let remainder = value & ((1u << shiftU32) - 1u);
145  if (remainder > halfShift || (remainder == halfShift && (truncated & 1u) == 1u)) {
146    return truncated + 1u;
147  }
148  return truncated;
149}
150
151fn makeFloatImmediate(sign: u32, exponent: i32, mantissa: u32) -> u32 {
152  return (sign << 31u) | (u32(exponent + 127) << 23u) | (mantissa & 0x7fffffu);
153}
154
155fn makeFloat(sign: u32, exponent: i32, significand: u32) -> u32 {
156  if (significand == 0u) {
157    return sign << 31u;
158  }
159
160  let leadingZeros = i32(countLeadingZeros(significand));
161  var normalizedExponent = exponent + 31 - leadingZeros;
162
163  if (normalizedExponent > 127) {
164    return (sign << 31u) | F32_INF;
165  }
166
167  var mantissa: u32;
168  if (normalizedExponent >= -126) {
169    mantissa = roundShiftRight(significand, 8 - leadingZeros);
170    if (mantissa >= 0x1000000u) {
171      mantissa = mantissa >> 1u;
172      normalizedExponent += 1;
173      if (normalizedExponent > 127) {
174        return (sign << 31u) | F32_INF;
175      }
176    }
177    return makeFloatImmediate(sign, normalizedExponent, mantissa);
178  }
179
180  let subnormalShift = -149 - exponent;
181  mantissa = roundShiftRight(significand, subnormalShift);
182  if (mantissa >= 0x800000u) {
183    return (sign << 31u) | (1u << 23u);
184  }
185  return (sign << 31u) | mantissa;
186}
187
188fn parseAsDouble(words: vec2<u32>) -> vec2<u32> {
189  var d = words;
190  if (LE) {
191    d = d.yx;
192  }
193
194  let sign = (d.x >> 31u) & 1u;
195  let exponentBits = (d.x >> 20u) & 0x7ffu;
196  let exponent = i32(exponentBits) - 1023;
197  let fractionHigh = d.x & 0xfffffu;
198  let fractionLow = d.y;
199
200  if (exponentBits == 0x7ffu) {
201    if (fractionHigh == 0u && fractionLow == 0u) {
202      return vec2<u32>((sign << 31u) | F32_INF, F32_NAN);
203    }
204    return vec2<u32>(F32_NAN);
205  }
206
207  if (exponentBits == 0u) {
208    return vec2<u32>(sign << 31u);
209  }
210
211  if (exponent > 127) {
212    return vec2<u32>((sign << 31u) | F32_INF, ((1u - sign) << 31u) | F32_INF);
213  }
214
215  let highSignificand = 0x800000u | (fractionHigh << 3u) | (fractionLow >> 29u);
216  let lowSignificand = fractionLow & 0x1fffffffu;
217
218  if (exponent < -126) {
219    let highPart = makeFloat(sign, exponent - 23, highSignificand);
220    let lowPart = makeFloat(sign, exponent - 52, lowSignificand);
221    return vec2<u32>(highPart, lowPart);
222  }
223
224  let roundUp = lowSignificand > 0x10000000u ||
225    (lowSignificand == 0x10000000u && (highSignificand & 1u) == 1u);
226
227  var roundedSignificand = highSignificand + select(0u, 1u, roundUp);
228  var highExponent = exponent;
229  if (roundedSignificand == 0x1000000u) {
230    roundedSignificand = 0x800000u;
231    highExponent += 1;
232  }
233
234  if (highExponent > 127) {
235    return vec2<u32>((sign << 31u) | F32_INF, ((1u - sign) << 31u) | F32_INF);
236  }
237
238  let highPart = makeFloatImmediate(sign, highExponent, roundedSignificand);
239
240  var remainder = i32(lowSignificand);
241  var lowSign = sign;
242  if (roundUp) {

243    remainder -= 0x20000000;
244  }
245  if (remainder < 0) {
246    lowSign = 1u - sign;
247    remainder = -remainder;
248  }
249
250  let lowPart = makeFloat(lowSign, exponent - 52, u32(remainder));
251  return vec2<u32>(highPart, lowPart);
252}
253
254fn fround(x: array<u32, {X_LEN}>) -> array<f32, {RESULT_LEN}> {
255  var result: array<f32, {RESULT_LEN}>;
256  let n = {X_LEN}u / 2u;
257  for (var i = 0u; i < n; i = i + 1u) {
258    let parts = parseAsDouble(vec2<u32>(x[i * 2u], x[i * 2u + 1u]));
259    result[i] = bitcast<f32>(parts.x);
260    result[i + n] = bitcast<f32>(parts.y);
261  }
262  return result;
263}
264`,P=({inputs:e,output:r,target:t})=>((0,a.P)({module:{name:"fround",source:I},inputs:e,output:r,operationType:"uint32",outputBuffer:t}),{success:!0}),T=async({inputs:e,output:r,target:t})=>{let{ids:n,sourceValues:i}=e,u=(0,s.iP)(n.type),a=[];n.isConstant||a.push({name:"ids",input:n,index:a.length}),i.isConstant||a.push({name:"sourceValues",input:i,index:a.length});let o=(0,h.BB)(Math.ceil(r.length/64),t.device.limits.maxComputeWorkgroupsPerDimension),l=`
265${a.map(({name:e,input:r,index:t})=>$(e,r,t)).join("\n")}
266${function(e,r){if(e.isConstant){let t=e.value;if(!t)throw Error(`Constant input ${e} is missing CPU values`);return`fn read_ids(_rowIndex: u32) -> ${r} {
267  return ${(0,s.Lm)(r,t[0]??0)};
268}`}let t=e.stride/e.ValueType.BYTES_PER_ELEMENT,n=e.offset/e.ValueType.BYTES_PER_ELEMENT;return`fn read_ids(rowIndex: u32) -> ${r} {
269  let rowOffset = ${n}u + rowIndex * ${t}u;
270  return ids[rowOffset];
271}`}(n,u)}
272${w(i,r.type)}
273${v(r,a.length)}
274${E(r)}
275${function(e,r){let t=(0,s._1)(e);return`fn zero_result() -> array<${(0,s.iP)(e)}, ${r}> {
276  var result: array<${(0,s.iP)(e)}, ${r}>;
277${Array.from({length:r},(e,r)=>`  result[${r}] = ${t};`).join("\n")}
278  return result;
279}`}(r.type,r.size)}
280${function(e,r,t,n){let i=(0,s.iP)(e),u=(0,s.iP)(r);return`fn gather(idsValue: ${i}) -> array<${u}, ${t}> {
281  let sourceIndex = ${"u32"===i?"i32(idsValue)":"i32"===i?"idsValue":"i32(idsValue)"};
282  if (sourceIndex < 0 || sourceIndex >= ${n}) {
283    return zero_result();
284  }
285  return read_source_values(u32(sourceIndex));
286}`}(n.type,r.type,r.size,i.length)}
287
288@compute @workgroup_size(64) fn main(
289  @builtin(workgroup_id) workgroupId: vec3<u32>,
290  @builtin(local_invocation_id) localId: vec3<u32>
291) {
292  let rowIndex = ${(0,h.vL)(o,64)};
293  if (rowIndex >= ${r.length}u) {
294    return;
295  }
296
297  let idsValue = read_ids(rowIndex);
298  let result = gather(idsValue);
299  write_result(rowIndex, result);
300}
301`,d=new x.C(t.device,{source:l,shaderLayout:{bindings:[...a.map(({name:e,index:r})=>({name:e,type:"storage",group:0,location:r})),{name:"result",type:"storage",group:0,location:a.length}]}}),f={};n.isConstant||(f.ids=n.buffer),i.isConstant||(f.sourceValues=i.buffer),f.result=t,d.setBindings(f);let p=t.device.beginComputePass({});return d.dispatch(p,o.x,o.y,o.z),p.end(),t.device.submit(),d.destroy(),{success:!0}},b=async({inputs:e,output:r,target:t})=>{var n;let{segments:i}=e,u=i.isConstant?[]:[{name:"segments",input:i,index:0}],a=(0,h.BB)(Math.ceil(r.length/64),t.device.limits.maxComputeWorkgroupsPerDimension),s=`
302${u.map(({name:e,input:r,index:t})=>$(e,r,t)).join("\n")}
303${y("segments",i,"uint32")}
304${v(r,u.length)}
305${E(r)}
306${(n=i.length,`fn segmented_map(vertexIndex: u32) -> array<u32, 2> {
307  var low = 0i;
308  var high = ${n}i;
309  while (low < high) {
310    let mid = low + (high - low) / 2i;
311    let midStart = read_segments(u32(mid))[0];
312    if (midStart <= vertexIndex) {
313      low = mid + 1i;
314    } else {
315      high = mid;
316    }
317  }
318
319  let segmentIndex = u32(max(low - 1i, 0i));
320  let segmentStart = read_segments(segmentIndex)[0];
321  return array<u32, 2>(segmentIndex, vertexIndex - segmentStart);
322}`)}
323
324@compute @workgroup_size(64) fn main(
325  @builtin(workgroup_id) workgroupId: vec3<u32>,
326  @builtin(local_invocation_id) localId: vec3<u32>
327) {
328  let rowIndex = ${(0,h.vL)(a,64)};
329  if (rowIndex >= ${r.length}u) {
330    return;
331  }
332
333  let result = segmented_map(rowIndex);
334  write_result(rowIndex, result);
335}
336`,o=new x.C(t.device,{source:s,shaderLayout:{bindings:[...u.map(({name:e,index:r})=>({name:e,type:"storage",group:0,location:r})),{name:"result",type:"storage",group:0,location:u.length}]}}),l=Object.fromEntries(u.map(({name:e,input:r})=>[e,r.buffer]));l.result=t,o.setBindings(l);let d=t.device.beginComputePass({});return o.dispatch(d,a.x,a.y,a.z),d.end(),t.device.submit(),o.destroy(),{success:!0}};var L=t(14071);let k=`\
337fn row_length(x: array<{TYPE}, {X_LEN}>) -> array<f32, 1> {
338  var sum = 0.0;
339  for (var i = 0u; i < {X_LEN}u; i = i + 1u) {
340    sum += f32(x[i]) * f32(x[i]);
341  }
342  return array<f32, 1>(sqrt(sum));
343}
344`,z=({inputs:e,output:r,target:t})=>((0,a.P)({module:{name:"row_length",source:k},inputs:e,output:r,operationType:"float32",outputBuffer:t}),{success:!0}

344),C=async({inputs:e,output:r,target:t})=>{let n=(0,s._1)(r.type);return(0,a.P)({module:{name:"select",source:"// inline expression select\n"},inputs:e,output:r,operationType:r.type,outputBuffer:t,expression:r=>{let t=S("condition",e.condition,r,n),i=S("whenTrue",e.whenTrue,r,n),u=S("whenFalse",e.whenFalse,r,n);return`select(${u}, ${i}, ${t} != ${n})`}}),{success:!0}};function S(e,r,t,n){return t<r.size?`${e}[${t}]`:1===r.size?`${e}[0]`:n}let N=({inputs:e,output:r,target:t})=>{let n=(0,h.BB)(Math.ceil(r.length/64),t.device.limits.maxComputeWorkgroupsPerDimension),i=`\
345@group(0) @binding(0) var<storage, read_write> result: array<i32>;
346
347@compute @workgroup_size(64) fn main(
348  @builtin(workgroup_id) workgroupId: vec3<u32>,
349  @builtin(local_invocation_id) localId: vec3<u32>
350) {
351  let rowIndex = ${(0,h.vL)(n,64)};
352  if (rowIndex >= ${r.length}u) {
353    return;
354  }
355
356  let rowOffset = ${r.offset/r.ValueType.BYTES_PER_ELEMENT}u + rowIndex * ${r.stride/r.ValueType.BYTES_PER_ELEMENT}u;
357  result[rowOffset] = ${e.start} + i32(rowIndex) * ${e.step};
358}
359`,u=new x.C(t.device,{source:i,shaderLayout:{bindings:[{name:"result",type:"storage",group:0,location:0}]}});u.setBindings({result:t});let a=t.device.beginComputePass({});return u.dispatch(a,n.x,n.y,n.z),a.end(),t.device.submit(),u.destroy(),{success:!0}},B=({inputs:e,output:r,target:t})=>{let{columns:n}=e;return(0,a.P)({module:{name:"swizzle",source:"// swizzle expression handled inline"},expression:e=>`x[${n[e]}]`,inputs:{x:e.x},output:r,outputBuffer:t}),{success:!0}}},33386:(e,r,t)=>{t.d(r,{W:()=>n});function n(e,r){return!function e(r,{operations:t,inputs:n}){switch(r.kind){case"input":if(!(r.name in n))throw Error(`Unknown expression input '${r.name}'`);return;case"literal":if(Array.isArray(r.value)){for(let e of r.value)if(!Number.isFinite(e))throw Error(`Expression literal array must contain only finite values, got ${e}`)}else if(!Number.isFinite(r.value))throw Error(`Expression literal must be finite, got ${r.value}`);return;case"call":{let i=t[r.op];if(!i)throw Error(`Unknown expression op '${r.op}'`);if(r.args.length!==i.arity)throw Error(`Expression op '${r.op}' expects ${i.arity} args, got ${r.args.length}`);for(let i of r.args)e(i,{operations:t,inputs:n});return}default:throw Error(`Unsupported expression node ${r.kind}`)}}(e,r),function e(r,t){switch(r.kind){case"input":{let e=t.inputs[r.name];if(t.laneIndex<e.size)return t.formatInput(r.name);return t.formatOutOfBoundsInput(r.name)}case"literal":return t.formatLiteral(r.value);case"call":{let n=t.operations[r.op],i=r.args.map(r=>e(r,t));return t.formatCall(n.symbol,i)}default:throw Error(`Unsupported expression node ${r.kind}`)}}(e,r)}}}]);