| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script id="shared"> |
| const log = console.debug; |
| |
| async function gc() { |
| await 0; |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUComputePassEncoder} computePassEncoder |
| */ |
| function clearResourceUsages(device, computePassEncoder) { |
| let code = `@compute @workgroup_size(1) fn c() {}`; |
| let module = device.createShaderModule({code}); |
| computePassEncoder.setPipeline(device.createComputePipeline( |
| { |
| layout: 'auto', |
| compute: {module}, |
| })); |
| computePassEncoder.dispatchWorkgroups(1); |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| const videoUrls = [ |
| |
| ]; |
| |
| /** |
| * @param {number} index |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData(index) { |
| let video = document.createElement('video'); |
| video.src = videoUrls[index % videoUrls.length]; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| /** |
| * @param {string} payload |
| * @returns {string} |
| */ |
| function toBlobUrl(payload) { |
| let blob = new Blob([payload], {type: 'text/javascript'}); |
| return URL.createObjectURL(blob); |
| } |
| </script> |
| <script> |
| globalThis.testRunner?.waitUntilDone(); |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| 'float32-blendable', |
| 'float16-renderable', |
| 'core-features-and-limits', |
| 'timestamp-query', |
| ], |
| }); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 82, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 436, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let texture0 = device0.createTexture({ |
| size: [128, 128, 26], |
| format: 'eac-rg11unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let commandEncoder1 = device0.createCommandEncoder(); |
| let texture1 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| adapter0.label = '\u534b\u0936\u0f92\u{1f64a}\u{1ff53}\u0f10\u5950\u1a7a\u5af4\u8131'; |
| } catch {} |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 82, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 436, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let textureView0 = texture0.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture2 = device0.createTexture({size: [40], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST}); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 82, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 436, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let buffer0 = device0.createBuffer({size: 36, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder2 = device0.createCommandEncoder(); |
| let textureView1 = texture1.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let textureView2 = texture0.createView({dimension: 'cube', baseArrayLayer: 3}); |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'smpte170m'} }); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 82, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 436, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout3, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout1], |
| }); |
| let sampler0 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 78.94, compare: 'equal'}); |
| let pipelineLayout1 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0], |
| }); |
| let commandEncoder3 = device0.createCommandEncoder(); |
| let textureView3 = texture0.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass(); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| await gc(); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let texture3 = device0.createTexture({size: [160, 120, 36], format: 'rg32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| commandEncoder2.insertDebugMarker('\ub42b'); |
| } catch {} |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let textureView4 = texture1.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let commandEncoder6 = device0.createCommandEncoder(); |
| let videoFrame1 = videoFrame0.clone(); |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| /* used global variables: buffer10, buffer2, buffer3, et1, et3 */ |
| @must_use |
| fn fn1(a0: ptr<function, f16>) -> u32 { |
| var out: u32; |
| let ptr0: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer3[unconst_u32(119464450)][unconst_u32(888065090)][unconst_u32(63950127)][unconst_u32(64714670)]; |
| loop { |
| let ptr1: ptr<storage, f16, read_write> = &(*&buffer3)[arrayLength(&(*&buffer3))][0][unconst_u32(1051389804)][unconst_u32(304548089)][0][unconst_u32(470937205)]; |
| _ = fn0(); |
| let ptr2: ptr<uniform, vec4f> = &(*&buffer10)[unconst_u32(3278408423)][0][unconst_u32(238194351)][0]; |
| break; |
| _ = buffer10; |
| _ = et3; |
| _ = buffer3; |
| _ = et1; |
| } |
| { |
| out = pack4xI8Clamp((*&buffer2)[unconst_u32(893946683)][0][7].location_7); |
| _ = buffer2; |
| } |
| let ptr3: ptr<storage, f16, read_write> = &buffer3[unconst_u32(336399353)][0][unconst_u32(1619556421)][unconst_u32(106159939)][unconst_u32(1001453521)][0]; |
| let ptr4: ptr<storage, f16, read_write> = &buffer3[unconst_u32(1955780111)][0][unconst_u32(53360426)][0][0][0]; |
| let ptr5: ptr<storage, array<f16, 1>, read_write> = &(*&buffer3)[unconst_u32(300307892)][unconst_u32(517182796)][60][unconst_u32(432327389)][0]; |
| return out; |
| _ = buffer10; |
| _ = et1; |
| _ = et3; |
| _ = buffer2; |
| _ = buffer3; |
| } |
| |
| @group(3) @binding(1) var tex3: texture_depth_2d; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(3) @binding(37) var<storage, read_write> buffer8: array<array<array<f16, 61>, 1>>; |
| |
| @group(0) @binding(0) var<storage, read_write> buffer1: array<array<array<array<array<f16, 1>, 1>, 20>, 8>>; |
| |
| struct VertexInput3 { |
| @location(8) location_8: vec4i, |
| } |
| |
| @group(1) @binding(436) var et1: texture_external; |
| |
| @group(0) @binding(1) var sam0: sampler_comparison; |
| |
| struct T5 { |
| f0: array<atomic<i32>>, |
| } |
| |
| @group(3) @binding(144) var<uniform> buffer10: array<array<array<array<vec4f, 1>, 3>, 1>, 2>; |
| |
| struct T1 { |
| @align(4) f0: array<bool>, |
| } |
| |
| struct VertexOutput0 { |
| @location(8) location_8: vec4h, |
| @builtin(position) position: vec4f, |
| @location(6) @interpolate(perspective, centroid) location_6: vec2h, |
| @location(13) location_13: vec2u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* used global variables: et1, et3 */ |
| @must_use |
| fn fn0() -> vec4h { |
| var out: vec4h; |
| let vf0: vec4f = textureLoad(et1, vec2u(unconst_u32(1252920021), unconst_u32(926603625))); |
| out = vec4h(f16(pack4xI8(vec4i(unconst_i32(237337379), unconst_i32(114259052), unconst_i32(84851739), unconst_i32(87157145))))); |
| out = mix(vec3h(unconst_f16(-10284.5), unconst_f16(5430.4), unconst_f16(12655.5)), vec3h(unconst_f16(2252.0), unconst_f16(10686.8), unconst_f16(5261.4)), unconst_f16(3828.5)).grbb; |
| let vf1: vec2u = textureDimensions(et1); |
| var vf2: vec2h = inverseSqrt(mix(vec3h(unconst_f16(1658.2), unconst_f16(818.1), unconst_f16(22061.0)), vec3h(unconst_f16(1149.3), unconst_f16(7167.9), unconst_f16(1257.5)), unconst_f16(5524.9)).xy); |
| vf2 *= out.br; |
| out -= vec4h(vec4h(unconst_f16(9919.3), unconst_f16(4978.1), unconst_f16(26900.3), unconst_f16(10161.6))); |
| var vf3: vec4u = (vec4u(unconst_u32(1333285427), unconst_u32(522708368), unconst_u32(576186117), unconst_u32(324585574)) / unconst_u32(169190413)); |
| let vf4: u32 = vf1[unconst_u32(529789045)]; |
| return out; |
| _ = et3; |
| _ = et1; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw0: atomic<u32>; |
| |
| struct VertexInput4 { |
| @builtin(vertex_index) vertex_index: u32, |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct T4 { |
| @align(64) f0: array<vec4i>, |
| } |
| |
| /* used global variables: buffer3, buffer8, et1, et3 */ |
| fn fn2(a0: ptr<uniform, vec4f>) -> vec2f { |
| var out: vec2f; |
| let ptr6: ptr<storage, f16, read_write> = &(*&buffer3)[arrayLength(&(*&buffer3))][unconst_u32(1604335472)][60][0][u32(buffer3[arrayLength(&buffer3)][0][unconst_u32(140933812)][unconst_u32(505657013)][0][0])][0]; |
| let ptr7: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer3[unconst_u32(39335350)][unconst_u32(384489539)][60][0]; |
| let ptr8: ptr<storage, array<f16, 1>, read_write> = &buffer3[arrayLength(&buffer3)][0][60][unconst_u32(632723924)][u32((*&buffer3)[arrayLength(&(*&buffer3))][0][unconst_u32(569326548)][0][0][0])]; |
| let ptr9: ptr<storage, f16, read_write> = &buffer3[arrayLength(&buffer3)][0][60][unconst_u32(160957773)][0][0]; |
| { |
| out = vec2f(f32(buffer3[arrayLength(&buffer3)][unconst_u32(3639983204)][unconst_u32(622068659)][0][0][0])); |
| _ = buffer3; |
| } |
| var vf5 = fn0(); |
| while bool((*&buffer8)[arrayLength(&(*&buffer8))][0][60]) { |
| if bool((*&buffer8)[arrayLength(&(*&buffer8)) - 1][0][60]) { |
| var vf6 = fn0(); |
| var vf7 = fn0(); |
| break; |
| _ = et1; |
| _ = et3; |
| } |
| _ = fn0(); |
| _ = et3; |
| _ = et1; |
| _ = buffer8; |
| } |
| let vf8: vec4f = textureLoad(et1, vec2u(unconst_u32(769746358), unconst_u32(112936702))); |
| let ptr10: ptr<storage, f16, read_write> = &buffer3[unconst_u32(26068463)][unconst_u32(13820355)][60][0][0][0]; |
| buffer3[unconst_u32(632572665)][unconst_u32(41983067)][60][u32((*&buffer8)[unconst_u32(4531791)][0][60])][unconst_u32(1076283985)][unconst_u32(185103923)] *= buffer3[unconst_u32(631262600)][unconst_u32(1151035096)][unconst_u32(1646346669)][0][0][unconst_u32(1096148788)]; |
| let ptr11: ptr<storage, f16, read_write> = &buffer3[unconst_u32(785250965)][unconst_u32(2359360469)][unconst_u32(110405579)][0][0][0]; |
| return out; |
| _ = et3; |
| _ = buffer8; |
| _ = et1; |
| _ = buffer3; |
| } |
| |
| struct T0 { |
| @size(122) f0: mat4x4h, |
| } |
| |
| struct T3 { |
| @size(256) f0: T0, |
| @align(256) f1: array<atomic<u32>>, |
| } |
| |
| struct ComputeInput0 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @group(1) @binding(37) var<storage, read_write> buffer3: array<array<array<array<array<array<f16, 1>, 1>, 1>, 61>, 1>>; |
| |
| struct T2 { |
| @align(8) f0: array<array<atomic<i32>, 2>>, |
| } |
| |
| struct ComputeInput1 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| @group(1) @binding(144) var<uniform> buffer5: array<array<array<vec4i, 2>, 1>, 3>; |
| |
| @group(3) @binding(436) var et3: texture_external; |
| |
| @group(2) @binding(70) var<uniform> buffer7: array<array<FragmentOutput0, 2>, 4>; |
| |
| struct VertexInput0 { |
| @location(10) location_10: vec2i, |
| @location(2) location_2: vec2i, |
| @location(1) location_1: vec2u, |
| @location(5) location_5: vec2u, |
| @location(15) location_15: vec4u, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: et1, et3 */ |
| @must_use |
| fn fn3() -> array<f16, 3> { |
| var out: array<f16, 3>; |
| let vf9: vec2<bool> = (vec2f(unconst_f32(0.3393), unconst_f32(0.1327e19)) >= vec2f(unconst_f32(0.01464), unconst_f32(-0.1574))); |
| var vf10: vec4f = refract(vec4f(unconst_f32(-0.05748e4), unconst_f32(0.07606), unconst_f32(0.1865), unconst_f32(0.07351e-26)), vec4f(unconst_f32(0.2648e-38), unconst_f32(0.3099), unconst_f32(-0.2170), unconst_f32(0.4079e27)), unconst_f32(0.1537)); |
| let ptr12: ptr<function, f16> = &out[unconst_u32(119128036)]; |
| for (var it0=vec3u((vec3h(unconst_f16(2230.0), unconst_f16(32010.9), unconst_f16(2229.0)) - vec3h(unconst_f16(15105.7), unconst_f16(5952.3), unconst_f16(23135.6))).gbb.brb)[1]; it0<(u32(out[unconst_u32(698647453)]) & 0xfff); it0++) { |
| out[unconst_u32(509472933)] = out[2]; |
| loop { |
| var vf11 = fn0(); |
| var vf12 = fn0(); |
| break; |
| _ = et3; |
| _ = et1; |
| } |
| while (unconst_bool(true) && unconst_bool(false)) { |
| out[unconst_u32(2193253248)] = out[2]; |
| } |
| out[unconst_u32(1530129019)] -= f16(unconst_f16(557.1)); |
| out[unconst_u32(765018132)] += out[2]; |
| return out; |
| _ = et3; |
| _ = et1; |
| } |
| out[unconst_u32(48398625)] = vec2h(unpack2x16unorm(unconst_u32(541869473)))[1]; |
| vf10 -= smoothstep(vec4f(unconst_f32(0.2054), unconst_f32(0.02822e32), unconst_f32(0.4480), unconst_f32(0.1472)), vec4f(unconst_f32(0.00057e-16), unconst_f32(0.09849e-7), unconst_f32(0.02632e34), unconst_f32(0.3723)), vec4f(unconst_f32(0.02120e0), unconst_f32(0.05476), unconst_f32(0.02590), unconst_f32(0.05489))); |
| let vf13: vec3h = (vec3h(unconst_f16(6220.1), unconst_f16(13680.8), unconst_f16(26959.5)) - vec3h(unconst_f16(-1572.3), unconst_f16(690.1), unconst_f16(-572.8))); |
| vf10 = ldexp(vec3f(unconst_f32(0.1072e0), unconst_f32(0.03246), unconst_f32(0.1087e14)), vec3i(unconst_i32(149151983), unconst_i32(52515776), unconst_i32(95811775))).xyyz; |
| switch u32(out[unconst_u32(585272556)]) { |
| case 219512878, default, 1991064499: { |
| var vf14: vec3i = extractBits(vec3i(unconst_i32(342698361), unconst_i32(105998057), unconst_i32(600592228)), unconst_u32(689296850), unconst_u32(936776594)); |
| break; |
| } |
| } |
| return out; |
| _ = et3; |
| _ = et1; |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput1 { |
| @location(7) location_7: vec2h, |
| } |
| |
| struct FragmentOutput0 { |
| @location(7) @interpolate(flat, center) location_7: vec4i, |
| @location(0) @interpolate(flat) location_0: vec4u, |
| } |
| |
| struct VertexInput2 { |
| @location(14) @interpolate(perspective, first) location_14: vec2f, |
| } |
| |
| @group(0) @binding(70) var<uniform> buffer2: array<array<array<FragmentOutput0, 8>, 1>, 1>; |
| |
| /* used global variables: buffer10, buffer5, et1, et3 */ |
| @vertex |
| fn vertex0(a0: VertexInput0, @location(3) location_3: vec2f, @location(0) location_0: vec4h, @location(9) location_9: vec2i, @location(11) @interpolate(flat) location_11: i32, a5: VertexInput1, a6: VertexInput2, a7: VertexInput3, a8: VertexInput4, @location(6) location_6: vec4h, @location(4) @interpolate(linear) location_4: vec4f, @location(12) @interpolate(linear, center) location_12: f16) -> VertexOutput0 { |
| var out: VertexOutput0; |
| let ptr13: ptr<uniform, vec4f> = &(*&buffer10)[1][unconst_u32(498482232)][2][u32(buffer5[2][0][1].a)]; |
| var vf15 = fn3(); |
| _ = fn3(); |
| out.position = vec4f(f32(buffer5[unconst_u32(156242347)][0][1][unconst_u32(289236416)])); |
| out.location_6 = a5.location_7; |
| return out; |
| _ = buffer5; |
| _ = et1; |
| _ = buffer10; |
| _ = et3; |
| } |
| |
| /* used global variables: buffer10, buffer2, buffer3, buffer7, buffer8, et1, et3, sam0, tex3 */ |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| let ptr14: ptr<storage, f16, read_write> = &buffer3[arrayLength(&buffer3)][0][unconst_u32(1413310118)][unconst_u32(1227431827)][unconst_u32(763026885)][unconst_u32(1232284644)]; |
| let ptr15: ptr<storage, array<f16, 1>, read_write> = &(*&buffer3)[unconst_u32(356147174)][0][unconst_u32(646835637)][0][0]; |
| out = buffer7[unconst_u32(544073354)][unconst_u32(554864958)]; |
| _ = fn3(); |
| let ptr16: ptr<uniform, vec4i> = &(*&buffer2)[unconst_u32(1039358412)][0][7].location_7; |
| var vf16 = fn2(&buffer10[1][0][2][unconst_u32(1112488970)]); |
| var vf17: vec4f = textureGatherCompare(tex3, sam0, vec2f(unconst_f32(0.1082), unconst_f32(0.3975e25)), unconst_f32(-0.1195e29)); |
| vf17 -= vec4f(f32((*&buffer3)[arrayLength(&(*&buffer3))][unconst_u32(1060895352)][60][0][0][unconst_u32(1480151287)])); |
| return out; |
| _ = buffer10; |
| _ = buffer2; |
| _ = buffer3; |
| _ = sam0; |
| _ = et3; |
| _ = et1; |
| _ = buffer7; |
| _ = buffer8; |
| _ = tex3; |
| } |
| |
| /* used global variables: buffer1, buffer3, buffer8, et1, et3 */ |
| @compute @workgroup_size(8, 1, 2) |
| fn compute0(a0: ComputeInput0, a1: ComputeInput1, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) { |
| var vf18: u32 = atomicLoad(&vw0); |
| var vf19 = fn3(); |
| buffer1[unconst_u32(413687389)][unconst_u32(571154783)][19][unconst_u32(82967563)][unconst_u32(554898092)] += buffer3[unconst_u32(123509912)][unconst_u32(503441112)][60][0][unconst_u32(128548198)][0]; |
| buffer8[unconst_u32(33851746)][0][unconst_u32(1179756172)] = f16(vf18); |
| _ = fn0(); |
| let ptr17: ptr<storage, array<f16, 1>, read_write> = &(*&buffer3)[unconst_u32(235856461)][unconst_u32(1409783650)][unconst_u32(92803052)][unconst_u32(1120222987)][unconst_u32(1355127261)]; |
| _ = buffer1; |
| _ = buffer3; |
| _ = et3; |
| _ = buffer8; |
| _ = et1; |
| }`, |
| }); |
| let buffer11 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder7 = device0.createCommandEncoder(); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(3).fill(37), /* required buffer size: 3 */ |
| {offset: 3}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline0 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule0, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.BLUE}]}, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm8x2', offset: 0, shaderLocation: 14}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 2}, |
| {format: 'float16x4', offset: 0, shaderLocation: 12}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 15}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 11}, |
| {format: 'float32', offset: 0, shaderLocation: 4}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 758, shaderLocation: 3}, |
| {format: 'uint32x4', offset: 96, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 436, |
| attributes: [ |
| {format: 'unorm16x4', offset: 56, shaderLocation: 7}, |
| {format: 'uint8x4', offset: 80, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 48, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x4', offset: 4, shaderLocation: 0}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let commandEncoder8 = device0.createCommandEncoder({label: '\uc7ef\u0337'}); |
| let texture4 = device0.createTexture({size: [20, 15, 82], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder1 = commandEncoder1.beginComputePass(); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], stencilReadOnly: true}); |
| let buffer12 = device0.createBuffer({size: 106, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| try { |
| commandEncoder6.copyBufferToBuffer(buffer12, 40, buffer11, 4, 4); |
| } catch {} |
| try { |
| globalThis.someLabel = veryExplicitBindGroupLayout1.label; |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let texture5 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 1}, |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView5 = texture3.createView({baseArrayLayer: 5, arrayLayerCount: 4}); |
| let buffer13 = device0.createBuffer({size: 532, usage: GPUBufferUsage.INDIRECT}); |
| let textureView6 = texture5.createView({aspect: 'all'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 4, z: 51}, |
| aspect: 'all', |
| }, new Uint8Array(71).fill(56), /* required buffer size: 71 */ |
| {offset: 71, rowsPerImage: 72}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture6 = device0.createTexture({ |
| size: [30, 30, 12], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let textureView7 = texture0.createView({dimension: '2d', baseArrayLayer: 10}); |
| let computePassEncoder2 = commandEncoder9.beginComputePass(); |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 0, new DataView(new Uint8Array(4878).map((_, i) => i).buffer), 1495, 4); |
| } catch {} |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(2, undefined, 1_182_126_490, 31_480_441); |
| } catch {} |
| let buffer14 = device0.createBuffer({size: 56, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 0, new Float32Array(9569).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4026)), 4277, 0); |
| } catch {} |
| let imageData0 = new ImageData(24, 20); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer12, 'uint16', 26, 18); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let canvas0 = document.createElement('canvas'); |
| await gc(); |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 82, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 436, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let texture7 = device0.createTexture({ |
| label: '\u65f1\ucb8b\u0879\u08a7\u5557\u10bd', |
| size: {width: 120, height: 120, depthOrArrayLayers: 49}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView8 = texture1.createView({mipLevelCount: 1}); |
| let computePassEncoder3 = commandEncoder6.beginComputePass(); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer14, 'uint16', 26, 2); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let texture8 = device0.createTexture({ |
| size: [128], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder4 = commandEncoder10.beginComputePass(); |
| let buffer15 = device0.createBuffer({size: 135, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let computePassEncoder5 = commandEncoder4.beginComputePass(); |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let buffer16 = device0.createBuffer({size: 44, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let computePassEncoder6 = commandEncoder12.beginComputePass(); |
| document.body.append(canvas0); |
| let imageData1 = new ImageData(24, 112); |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| let textureView9 = texture3.createView({aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 16}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer12, 'uint32', 28, 9); |
| } catch {} |
| let buffer17 = device0.createBuffer({size: 323, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer14, 'uint32', 12, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 16, new Uint32Array(4369).map((_, i) => i * 8), 1383, 4); |
| } catch {} |
| try { |
| textureView8.label = '\u0b86\u{1fce9}\u{1f85e}'; |
| } catch {} |
| let buffer18 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder15 = device0.createCommandEncoder({label: '\u0a3c\ub342\u0dac\u7fb6\u651e\u{1fbbf}\uc5b5\u2110'}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(2, buffer17, 160, 8); |
| } catch {} |
| try { |
| commandEncoder15.clearBuffer(buffer15, 4, 0); |
| } catch {} |
| try { |
| commandEncoder15.insertDebugMarker('\u231f'); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| await gc(); |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer17, 0, 41); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToBuffer(buffer17, 4, buffer15, 60, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture9 = device0.createTexture({ |
| size: [60, 60, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer15, 4, new Float32Array(16489).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5740)), 1182, 12); |
| } catch {} |
| document.body.append(canvas0); |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| requires unrestricted_pointer_parameters; |
| |
| struct T0 { |
| @size(88) f0: vec2h, |
| } |
| |
| @id(48437) override override4: bool; |
| |
| @group(0) @binding(37) var<storage, read_write> buffer19: array<array<f16, 61>>; |
| |
| struct FragmentOutput1 { |
| @location(0) @interpolate(flat) location_0: vec4u, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| var<workgroup> vw1: atomic<i32>; |
| |
| /* used global variables: buffer20 */ |
| fn fn0(a0: ptr<storage, array<f16, 61>, read_write>) { |
| let ptr18: ptr<storage, array<f16, 1>, read> = &buffer20[unconst_u32(1265281659)][u32(buffer20[3][unconst_u32(1374367397)][0][unconst_u32(677042792)][0][unconst_u32(1445862285)])][0][unconst_u32(234428678)][unconst_u32(65224701)]; |
| (*a0)[unconst_u32(535563549)] -= (*&buffer20)[unconst_u32(698221477)][1][unconst_u32(1920311687)][u32(buffer20[3][1][0][0][0][0])][unconst_u32(269125335)][unconst_u32(1108829031)]; |
| let ptr19: ptr<storage, f16, read> = &(*&buffer20)[3][unconst_u32(394140240)][0][0][unconst_u32(9282960)][0]; |
| _ = buffer20; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct FragmentInput2 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| override override0: u32; |
| |
| @group(1) @binding(1) var tex7: texture_depth_2d; |
| |
| struct T1 { |
| @size(32) f0: i32, |
| @size(64) f1: atomic<i32>, |
| } |
| |
| @group(0) @binding(144) var<uniform> buffer21: array<array<array<array<mat2x4h, 3>, 1>, 1>, 2>; |
| |
| @group(1) @binding(37) var<storage, read_write> buffer22: array<array<array<f16, 61>, 1>>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @id(3948) override override1: f16; |
| |
| struct FragmentInput0 { |
| @location(6) @interpolate(perspective, centroid) location_6: vec2h, |
| } |
| |
| struct ComputeInput2 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(0) @binding(82) var<storage, read> buffer20: array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 2>, 4>; |
| |
| override override3: u32; |
| |
| alias vec3b = vec3<bool>; |
| |
| @id(24728) override override2: i32; |
| |
| var<workgroup> vw2: vec4<bool>; |
| |
| struct FragmentInput1 { |
| @location(13) location_13: vec2u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* used global variables: buffer19, buffer21, buffer22, tex7 */ |
| @fragment |
| fn fragment1(a0: FragmentInput0, a1: FragmentInput1, @location(8) location_8: vec4h, @builtin(front_facing) front_facing: bool, a4: FragmentInput2) -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let ptr20: ptr<storage, f16, read_write> = &buffer19[arrayLength(&buffer19)][60]; |
| buffer22[unconst_u32(1175544312)][unconst_u32(11547822)][unconst_u32(158854629)] = buffer22[unconst_u32(661482748)][unconst_u32(450316213)][unconst_u32(80235463)]; |
| let ptr21: ptr<storage, array<f16, 61>, read_write> = &buffer22[arrayLength(&buffer22)][unconst_u32(177545168)]; |
| var vf20: vec2u = textureDimensions(tex7, unconst_i32(92790853)); |
| out.sample_mask = u32((*&buffer21)[1][unconst_u32(1432778498)][0][2][unconst_u32(1537722836)][0]); |
| return out; |
| _ = buffer21; |
| _ = buffer22; |
| _ = buffer19; |
| _ = tex7; |
| } |
| |
| /* used global variables: buffer19, buffer20, buffer22 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute1(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a3: ComputeInput2, @builtin(num_workgroups) num_workgroups: vec3u) { |
| buffer19[u32((*&buffer20)[3][1][0][unconst_u32(268568871)][0][unconst_u32(570477539)])][unconst_u32(918579309)] = (*&buffer20)[unconst_u32(69626174)][1][0][unconst_u32(398054561)][unconst_u32(195745097)][unconst_u32(297504606)]; |
| let ptr22: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer20[3][unconst_u32(794588800)][0]; |
| let ptr23: ptr<storage, f16, read_write> = &buffer19[arrayLength(&buffer19)][60]; |
| buffer22[unconst_u32(140315179)][unconst_u32(703020073)][unconst_u32(447818195)] = (*&buffer20)[unconst_u32(283196713)][1][u32(buffer20[unconst_u32(425449346)][unconst_u32(90996626)][unconst_u32(16637767)][0][0][0])][unconst_u32(509679854)][0][0]; |
| fn0(&buffer22[unconst_u32(905998896)][0]); |
| fn0(&buffer22[unconst_u32(584555375)][0]); |
| let ptr24: ptr<storage, array<f16, 61>, read_write> = &buffer22[unconst_u32(678557542)][0]; |
| let ptr25: ptr<storage, array<f16, 1>, read> = &(*&buffer20)[unconst_u32(388853099)][1][0][0][unconst_u32(1734968017)]; |
| fn0(&buffer22[unconst_u32(1824386796)][unconst_u32(1443169008)]); |
| for (var it1=u32(buffer19[unconst_i32(-266419945)][60]); it1<(u32(buffer20[3][1][unconst_u32(511693124)][unconst_u32(439730457)][unconst_u32(666012001)][0]) & 0xfff); it1++) { |
| buffer22[unconst_u32(640883336)][unconst_u32(884316598)][unconst_u32(299267521)] += (*&buffer22)[arrayLength(&(*&buffer22))][unconst_u32(572140002)][unconst_u32(2069252059)]; |
| atomicCompareExchangeWeak(&vw1, unconst_i32(144925476), unconst_i32(298623337)); |
| fn0(&(*&buffer19)[unconst_u32(323843208)]); |
| atomicCompareExchangeWeak(&vw1, i32(buffer20[3][unconst_u32(2017238306)][0][0][unconst_u32(1251299439)][0]), unconst_i32(103688144)); |
| let ptr26: ptr<storage, f16, read> = &(*&buffer20)[3][1][0][0][0][unconst_u32(64256613)]; |
| switch i32(buffer20[3][1][0][0][0][0]) { |
| case 519418911, default: { |
| buffer19[unconst_u32(78124638)][60] = (*&buffer20)[3][u32(buffer20[unconst_u32(229323108)][unconst_u32(482308157)][unconst_u32(487035962)][0][0][unconst_u32(2827682807)])][unconst_u32(57418669)][0][bitcast<u32>(floor(vec2h(unconst_f16(8958.7), unconst_f16(-18939.9))))][0]; |
| return; |
| _ = buffer19; |
| _ = buffer20; |
| } |
| } |
| _ = buffer22; |
| _ = buffer20; |
| _ = buffer19; |
| } |
| atomicMin(&vw1, unconst_i32(45640256)); |
| let ptr27: ptr<storage, f16, read_write> = &buffer22[arrayLength(&buffer22)][u32(buffer19[arrayLength(&buffer19)][60])][unconst_u32(37499313)]; |
| _ = buffer22; |
| _ = buffer20; |
| _ = buffer19; |
| }`, |
| }); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let promise0 = shaderModule0.getCompilationInfo(); |
| try { |
| buffer11.destroy(); |
| } catch {} |
| let pipeline1 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg32uint'}]}, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'float32x3', offset: 68, shaderLocation: 7}, |
| {format: 'unorm16x2', offset: 872, shaderLocation: 12}, |
| {format: 'sint8x4', offset: 12, shaderLocation: 8}, |
| {format: 'snorm16x4', offset: 24, shaderLocation: 6}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 1}, |
| {format: 'sint32x3', offset: 552, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 300, shaderLocation: 5}, |
| {format: 'float32x4', offset: 624, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 188, shaderLocation: 4}, |
| {format: 'sint16x2', offset: 436, shaderLocation: 11}, |
| {format: 'snorm16x2', offset: 940, shaderLocation: 14}, |
| {format: 'sint16x4', offset: 400, shaderLocation: 9}, |
| {format: 'float32', offset: 64, shaderLocation: 0}, |
| {format: 'sint8x4', offset: 132, shaderLocation: 10}, |
| {format: 'uint8x2', offset: 48, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let buffer24 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let texture10 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeBuffer(buffer24, 0, new Float16Array(14074).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.2991)), 106, 4); |
| } catch {} |
| let imageData2 = new ImageData(12, 24); |
| let commandEncoder18 = device0.createCommandEncoder(); |
| let sampler1 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 66.88}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer17, 'uint32', 32, 28); |
| } catch {} |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let texture11 = device0.createTexture({ |
| size: {width: 40, height: 30, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| buffer11.unmap(); |
| } catch {} |
| let texture12 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView10 = texture9.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(0, buffer17, 88, 15); |
| } catch {} |
| try { |
| buffer17.unmap(); |
| } catch {} |
| await gc(); |
| let canvas1 = document.createElement('canvas'); |
| let videoFrame2 = new VideoFrame(canvas0, {timestamp: 0}); |
| let textureView11 = texture10.createView({label: '\u0de4\u4453\ub155\u0f58', baseArrayLayer: 0}); |
| let textureView12 = texture5.createView({dimension: '2d-array'}); |
| let renderPassEncoder0 = commandEncoder2.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: 789.2, g: -573.4, b: 12.16, a: -274.5, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| commandEncoder8.copyTextureToTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 8, y: 7, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 2, y: 27, z: 2}, |
| aspect: 'all', |
| }, |
| {width: 23, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 266}); |
| let texture13 = device0.createTexture({ |
| size: [120, 120, 49], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView13 = texture6.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder1.setVertexBuffer(1, buffer17, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 4, new DataView(new Uint8Array(14942).map((_, i) => i).buffer), 7653, 40); |
| } catch {} |
| let buffer25 = device0.createBuffer({size: 19836, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture14 = device0.createTexture({ |
| size: [120, 120, 49], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer14, 'uint32', 0, 21); |
| } catch {} |
| try { |
| commandEncoder8.copyBufferToBuffer(buffer12, 8, buffer15, 8, 4); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'linear'} }); |
| let texture15 = device0.createTexture({ |
| size: {width: 160, height: 120, depthOrArrayLayers: 32}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder1 = commandEncoder3.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -803.5, g: -681.7, b: -604.7, a: 574.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 17842798, |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer14, 'uint16', 4, 7); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData3 = new ImageData(40, 124); |
| let buffer26 = device0.createBuffer({ |
| label: '\u0e11\u0faa\u97ee\u{1fdc9}\u2e51\u0da3\u396b\u{1fd9e}\u8d6e', |
| size: 132, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let textureView14 = texture15.createView({baseArrayLayer: 3, arrayLayerCount: 1}); |
| let computePassEncoder7 = commandEncoder17.beginComputePass(); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer24, 'uint32', 0, 3); |
| } catch {} |
| let texture16 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture17 = device0.createTexture({ |
| size: [60, 60, 19], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView15 = texture13.createView({dimension: '3d', baseMipLevel: 0}); |
| try { |
| renderPassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| await gc(); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let texture18 = device0.createTexture({ |
| size: {width: 160, height: 120, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder2 = commandEncoder11.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -237.4, g: 399.0, b: 81.99, a: -787.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 4001573, |
| }); |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder8.copyBufferToBuffer(buffer12, 12, buffer24, 0, 0); |
| } catch {} |
| try { |
| await promise0; |
| } catch {} |
| let textureView16 = texture18.createView({dimension: '2d-array'}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer14, 'uint16', 8, 23); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| label: '\u6f3c\u{1f9a7}\u2cff\uf2e4\u4b57\u0dfb', |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| var<private> vp1: f16 = f16(18421.9); |
| |
| struct T1 { |
| @size(1024) f0: vec2u, |
| f1: array<u32>, |
| } |
| |
| struct VertexInput9 { |
| @location(6) location_6: f16, |
| } |
| |
| struct FragmentOutput2 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(1) @interpolate(flat) location_1: i32, |
| @location(0) @interpolate(flat, sample) location_0: vec2u, |
| } |
| |
| @group(1) @binding(115) var st0: texture_storage_2d<r32float, read_write>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T2 { |
| @size(256) f0: array<array<atomic<i32>, 1>, 2>, |
| } |
| |
| /* zero global variables used */ |
| fn fn2() { |
| vp1 -= vp2[unconst_u32(229244798)]; |
| vp0.exp += vec3i(bitcast<i32>(clamp(unconst_f32(-0.03667e-39), faceForward(vec2f(unconst_f32(0.06426e-39), unconst_f32(0.2556e32)), vec2f(unconst_f32(0.09654e11), unconst_f32(0.3125)), vec2f(vp0.exp.gr.xy)).x, unconst_f32(-0.04058)))); |
| let ptr30: ptr<private, vec3f> = &vp0.fract; |
| vp2 = vec2h(max(vec2u(unconst_u32(303494924), unconst_u32(1594793077)), vec2u(unconst_u32(402586177), unconst_u32(203164222)))); |
| vp2 = vec2h(quantizeToF16(vec2f(unconst_f32(-0.1064), unconst_f32(-0.07218e11)))); |
| vp2 = vec2h(tanh(vec2f(unconst_f32(0.1252e-7), unconst_f32(0.00837))).yx.xx); |
| vp2 = vec2h(round(vec4f(clamp(unconst_f32(0.07622), unconst_f32(-0.2577), unconst_f32(0.1656e-20)))).xz); |
| let ptr31: ptr<private, vec3f> = &(*ptr30); |
| } |
| |
| @group(1) @binding(10) var<storage, read_write> buffer30: array<VertexInput9, 4>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentInput3 { |
| @location(6) @interpolate(perspective, centroid) location_6: vec2h, |
| } |
| |
| @group(0) @binding(1) var sam2: sampler_comparison; |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput7 { |
| @location(4) location_4: vec2u, |
| @builtin(instance_index) instance_index: u32, |
| @location(0) @interpolate(flat) location_0: i32, |
| @location(12) location_12: vec2h, |
| @location(10) location_10: vec2f, |
| } |
| |
| /* used global variables: buffer27, buffer29, buffer30, buffer32, st0 */ |
| fn fn3() { |
| buffer29[unconst_u32(1555948109)][unconst_u32(366613142)][unconst_u32(149451103)][unconst_u32(1375615290)] -= vec4h((*&buffer27)[arrayLength(&(*&buffer27))][15][9][0][0]); |
| var vf31 = fn0(); |
| let ptr32: ptr<workgroup, vec4i> = &(*&vw3)[0]; |
| buffer30[unconst_u32(46549400)].location_6 = f16((*&buffer32).y); |
| buffer29[unconst_u32(1152183199)][u32(buffer29[arrayLength(&buffer29)][7][unconst_u32(22919597)][unconst_u32(666252676)][1])][unconst_u32(655782692)][unconst_u32(3501114111)] -= vec4h((*&buffer27)[unconst_u32(974981834)][unconst_u32(1284856752)][unconst_u32(34233959)][0][unconst_u32(178755117)]); |
| var vf32 = fn0(); |
| var vf33 = fn0(); |
| _ = fn0(); |
| _ = fn0(); |
| _ = st0; |
| _ = buffer32; |
| _ = buffer27; |
| _ = buffer29; |
| _ = buffer30; |
| } |
| |
| struct VertexInput8 { |
| @location(8) location_8: vec4i, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer27: array<array<array<array<array<f16, 1>, 1>, 10>, 16>>; |
| |
| var<private> vp2: vec2h = vec2h(7063.3, 1843.4); |
| |
| struct VertexInput5 { |
| @location(9) @interpolate(linear) location_9: vec2f, |
| } |
| |
| /* used global variables: buffer29, st0 */ |
| @must_use |
| fn fn0() -> f32 { |
| var out: f32; |
| if bool(buffer29[arrayLength(&buffer29)][unconst_u32(191193553)][13][3][2]) { |
| textureStore(st0, vec2i(unconst_i32(232635694), unconst_i32(865858937)), vec4f(vec4f(unconst_f32(0.2419), unconst_f32(0.00158e29), unconst_f32(0.05879), unconst_f32(0.1500e-15)))); |
| vp2 = buffer29[arrayLength(&buffer29)][7][13][3].yw; |
| _ = buffer29; |
| _ = st0; |
| } |
| return out; |
| _ = buffer29; |
| _ = st0; |
| } |
| |
| struct T0 { |
| f0: array<atomic<i32>>, |
| } |
| |
| struct T3 { |
| f0: array<f16>, |
| } |
| |
| @group(2) @binding(10) var<storage, read_write> buffer32: vec2i; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp0 = frexp(vec3f(-0.06540, 0.3073e17, 0.2877e2)); |
| |
| struct T4 { |
| @size(128) f0: f16, |
| f1: array<array<vec2f, 20>, 1>, |
| @size(32) f2: vec4u, |
| @size(32) f3: vec4<bool>, |
| @size(2688) f4: array<vec4h, 3>, |
| @size(1024) f5: array<array<array<array<array<vec2i, 1>, 1>, 1>, 1>, 64>, |
| } |
| |
| @group(1) @binding(0) var<storage, read_write> buffer29: array<array<array<array<vec4h, 4>, 14>, 8>>; |
| |
| struct VertexInput6 { |
| @location(2) @interpolate(flat) location_2: vec2h, |
| } |
| |
| var<workgroup> vw3: array<vec4i, 1>; |
| |
| /* used global variables: sam2 */ |
| fn fn1(a0: ptr<private, vec3f>) -> vec4h { |
| var out: vec4h; |
| let ptr28 = &vp0; |
| let vf21: vec3u = countOneBits(vec3u(unconst_u32(453479565), unconst_u32(200111916), unconst_u32(37416292))); |
| (*a0) *= vec3f(vp0.exp.yzz); |
| while bool(degrees(bitcast<vec3f>((vec2i(unconst_i32(854364612), unconst_i32(123051469)) + vec2i(unconst_i32(269926071), unconst_i32(688283799))).yyy.rgg.rrr.gbg.zxz.zxz.rbb)).z) { |
| let vf22: vec4f = trunc(vec4f(unconst_f32(0.1529e-25), unconst_f32(0.03220e-21), unconst_f32(-0.1198), unconst_f32(0.04839e37))); |
| vp0 = frexp(round(vec2f(f32((unconst_bool(false) || unconst_bool(true))))).grr); |
| for (var it2=(vec2u(unconst_u32(897733088), unconst_u32(965774378)) & vec2u(unconst_u32(828734767), unconst_u32(624299609))).y; it2<(u32(out[unconst_u32(197195416)]) & 0xfff); it2++) { |
| _ = sam2; |
| let vf23: vec3f = refract(vec3f(unconst_f32(-0.6778), unconst_f32(0.4164), unconst_f32(0.4305)), vec3f(unconst_f32(0.05847), unconst_f32(0.7175e18), unconst_f32(0.06871e-1)), unconst_f32(0.04104)); |
| let vf24: vec3i = firstTrailingBit(vec3i(unconst_i32(-1867443052), unconst_i32(193512815), unconst_i32(1075053501))); |
| vp2 *= bitcast<vec2h>(vf24[unconst_u32(1402734055)]); |
| return out; |
| _ = sam2; |
| } |
| let ptr29: ptr<private, vec3f> = &vp0.fract; |
| (*a0) = vec3f(f32(pack4xU8(vec4u(unconst_u32(113505820), unconst_u32(528675951), unconst_u32(418208162), unconst_u32(634273978))))); |
| let vf25: vec3f = fma(vec3f(f32(pack4xU8Clamp(vec4u(unconst_u32(343627469), unconst_u32(601814029), unconst_u32(93839860), unconst_u32(1762935749))))), vec3f(unconst_f32(0.01339e-45), unconst_f32(0.4619e33), unconst_f32(0.09793)), trunc(vec4f(unconst_f32(0.04910e-36), unconst_f32(0.00168), unconst_f32(0.3529e12), unconst_f32(0.01230e-34))).grb); |
| _ = sam2; |
| } |
| let vf26: f32 = degrees(unconst_f32(0.01067)); |
| var vf27: vec2i = (vec2i(unconst_i32(354973367), unconst_i32(90071641)) + vec2i(unconst_i32(49895896), unconst_i32(-261152576))); |
| let vf28: vec2f = asin(vec2f(unconst_f32(0.3498e28), unconst_f32(0.5207))); |
| let vf29: vec4i = countOneBits(vec4i(unconst_i32(323079888), unconst_i32(-45250794), unconst_i32(86303850), unconst_i32(1023273626))); |
| let vf30: f32 = log2(unconst_f32(-0.1092e-9)); |
| return out; |
| _ = sam2; |
| } |
| |
| struct T5 { |
| f0: array<atomic<i32>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput1 { |
| @builtin(position) position: vec4f, |
| @location(11) location_11: vec4u, |
| @location(9) @interpolate(flat, center) location_9: vec2f, |
| @location(6) @interpolate(perspective, first) location_6: vec4f, |
| @location(5) location_5: vec4h, |
| @location(4) location_4: f16, |
| @location(3) location_3: vec2f, |
| } |
| |
| /* used global variables: sam2 */ |
| @vertex |
| fn vertex1(@builtin(vertex_index) vertex_index: u32, a1: VertexInput5, a2: VertexInput6, @location(11) @interpolate(flat, sample) location_11: vec2i, @location(5) @interpolate(flat) location_5: vec4u, a5: VertexInput7, @location(13) location_13: f16, @location(14) location_14: vec4i, a8: VertexInput8, a9: VertexInput9, @location(3) @interpolate(flat, centroid) location_3: i32, @location(1) @interpolate(flat, center) location_1: vec2i) -> VertexOutput1 { |
| var out: VertexOutput1; |
| let vf34: f16 = tanh(unconst_f16(18839.6)); |
| { |
| _ = fn1(&vp0.fract); |
| var vf35: i32 = a8.location_8[unconst_u32(1079192223)]; |
| let ptr33 = &vp0; |
| switch bitcast<u32>(a5.location_0) { |
| case default: { |
| let vf36: vec2u = a5.location_4; |
| out.position *= sqrt(vec3f(unconst_f32(0.02753), unconst_f32(0.01764e28), unconst_f32(0.4663e10))).bggb; |
| var vf37 = fn1(&vp0.fract); |
| var vf38: vec2i = (i32(sign(vec3h(unconst_f16(20314.6), unconst_f16(18100.8), unconst_f16(2831.9)))[1]) - vec2i(unconst_i32(-698780598), unconst_i32(-133736147))); |
| break; |
| _ = sam2; |
| } |
| } |
| out.location_6 += vec4f(f32(a9.location_6)); |
| while bool(a5.location_12.x) { |
| out.location_3 = a5.location_10; |
| fn1(&vp0.fract); |
| var vf39: u32 = a5.instance_index; |
| out.location_3 -= vec2f(bitcast<f32>(location_1[unconst_u32(227553505)])); |
| return out; |
| _ = sam2; |
| } |
| _ = sam2; |
| } |
| fn1(&vp0.fract); |
| { |
| let vf40: vec4f = unpack4x8unorm(unconst_u32(106274606)); |
| let ptr34: ptr<function, f16> = &out.location_4; |
| let vf41: f32 = out.location_6[unconst_u32(274690937)]; |
| vp0 = frexp(vec3f(f32(countTrailingZeros(vec4i(out.location_5)[1])))); |
| fn2(); |
| var vf42: i32 = location_11[unconst_u32(520634253)]; |
| } |
| out.position = unpack4x8snorm(countTrailingZeros(unconst_u32(981962243))); |
| out.location_6 *= vec4f(f32(a5.location_0)); |
| out.location_3 = vec2f(vec2f(f32(trunc(unconst_f16(6403.5))))); |
| return out; |
| _ = sam2; |
| } |
| |
| /* used global variables: buffer29, st0 */ |
| @fragment |
| fn fragment2(a0: FragmentInput3) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| out.location_1 = i32(buffer29[arrayLength(&buffer29)][7][unconst_u32(1024409941)][3][unconst_u32(218140859)]); |
| _ = fn0(); |
| return out; |
| _ = buffer29; |
| _ = st0; |
| } |
| |
| /* used global variables: buffer27, buffer29, buffer30, buffer32, st0 */ |
| @compute @workgroup_size(2, 1, 2) |
| fn compute2(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(local_invocation_id) local_invocation_id: vec3u) { |
| let ptr35: ptr<storage, vec4h, read_write> = &(*&buffer29)[unconst_u32(1078733529)][7][unconst_u32(1234377594)][3]; |
| fn3(); |
| _ = buffer32; |
| _ = buffer27; |
| _ = buffer29; |
| _ = st0; |
| _ = buffer30; |
| }`, |
| }); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer14, 'uint32', 4, 3); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await buffer26.mapAsync(GPUMapMode.READ, 0, 16); |
| } catch {} |
| document.body.append(canvas1); |
| let texture19 = device0.createTexture({size: [120], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer24, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(3, buffer17, 0, 122); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| document.body.prepend(canvas0); |
| document.body.prepend(canvas1); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'bt709'} }); |
| let renderPassEncoder3 = commandEncoder15.beginRenderPass({colorAttachments: [{view: textureView10, loadOp: 'load', storeOp: 'store'}]}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1, depthReadOnly: true}); |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer17); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(4, buffer17, 0, 136); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| try { |
| commandEncoder8.resolveQuerySet(querySet0, 9, 127, buffer25, 1280); |
| } catch {} |
| await gc(); |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 48, new Uint32Array(8741).map((_, i) => i * 2), 1644, 4); |
| } catch {} |
| let renderPassEncoder4 = commandEncoder21.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -14.01, g: -345.0, b: -363.8, a: -194.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 212298139, |
| }); |
| await gc(); |
| let texture20 = device0.createTexture({ |
| size: [30, 30, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder5 = commandEncoder16.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: 311.3, g: -139.3, b: 87.15, a: -897.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 553448143, |
| }); |
| try { |
| renderPassEncoder4.beginOcclusionQuery(24); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let buffer35 = device0.createBuffer({size: 52, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let commandEncoder22 = device0.createCommandEncoder(); |
| let texture21 = device0.createTexture({ |
| size: {width: 40, height: 30, depthOrArrayLayers: 3}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer24, 0, new Uint32Array(1101).map((_, i) => i * 6), 327, 0); |
| } catch {} |
| let textureView17 = texture13.createView({baseArrayLayer: 0}); |
| let renderPassEncoder6 = commandEncoder5.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: 982.1, g: 895.6, b: 627.8, a: 4.370, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| let sampler2 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', minFilter: 'nearest', compare: 'greater'}); |
| try { |
| renderBundleEncoder2.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder23 = device0.createCommandEncoder(); |
| let textureView18 = texture0.createView({dimension: 'cube', baseArrayLayer: 1, arrayLayerCount: 6}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(3, buffer17, 16); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer24, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer17, 44, 28); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder2.insertDebugMarker('\uca88'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext1 = canvas1.getContext('webgpu'); |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| enable f16; |
| |
| struct T2 { |
| f0: array<f16>, |
| } |
| |
| struct VertexInput11 { |
| @location(12) @interpolate(flat) location_12: vec4f, |
| @location(15) @interpolate(flat, centroid) location_15: f16, |
| } |
| |
| @group(3) @binding(3) var et8: texture_external; |
| |
| struct VertexOutput2 { |
| @location(6) location_6: vec4f, |
| @location(1) location_1: f16, |
| @location(8) location_8: vec4f, |
| @location(14) @interpolate(perspective, either) location_14: f32, |
| @location(7) location_7: f32, |
| @location(0) @interpolate(flat, sample) location_0: vec2u, |
| @location(13) location_13: vec2f, |
| @location(10) @interpolate(flat, first) location_10: vec2u, |
| @location(2) @interpolate(flat, sample) location_2: vec4f, |
| @location(9) location_9: vec4h, |
| @location(11) @interpolate(flat, sample) location_11: vec4i, |
| @builtin(position) position: vec4f, |
| } |
| |
| struct FragmentInput4 { |
| @location(8) location_8: vec4h, |
| } |
| |
| @group(2) @binding(70) var<uniform> buffer42: array<vec4f, 16>; |
| |
| var<workgroup> vw4: array<f16, 56>; |
| |
| /* used global variables: buffer40, buffer44, et9 */ |
| fn fn1(a0: vec4<bool>) -> array<array<array<vec2f, 2>, 1>, 13> { |
| var out: array<array<array<vec2f, 2>, 1>, 13>; |
| for (var jj1=0u; jj1<15; jj1++) { out[jj1][unconst_u32(1207139300)][unconst_u32(865478813)] += bitcast<vec2f>(buffer40[5].gr.rr); } |
| for (var jj93=0u; jj93<15; jj93++) { for (var jj30=0u; jj30<3; jj30++) { for (var jj46=0u; jj46<4; jj46++) { out[jj93][jj30][jj46] = bitcast<vec2f>(buffer44[5][0][0].location_0.xx.gg); } } } |
| let vf51: vec2h = step(bitcast<vec2h>(pack2x16unorm(vec2f(unconst_f32(0.09517), unconst_f32(0.1252)))), vec2h(buffer44[5][0][unconst_u32(1875665462)].location_0.xx)); |
| var vf52: u32 = buffer44[unconst_u32(1410080336)][0][(*&buffer44)[5][0][0].location_0[3]].location_0[unconst_u32(1311032058)]; |
| let ptr42: ptr<uniform, array<array<FragmentOutput3, 1>, 1>> = &buffer44[5]; |
| let ptr43: ptr<function, array<vec2f, 2>> = &out[12][unconst_u32(381239132)]; |
| let ptr44: ptr<uniform, FragmentOutput3> = &(*&buffer44)[5][0][unconst_u32(3421915001)]; |
| vf52 = pack4x8unorm(textureLoad(et9, vec2u(unconst_u32(192767892), unconst_u32(837880190)))); |
| vf52 >>= (*&buffer44)[5][0][unconst_u32(1120245654)].location_0[unconst_u32(775220954)]; |
| var vf53: u32 = buffer44[unconst_u32(488962909)][buffer44[5][bitcast<vec2u>((*ptr43)[1].xx.gg).g][unconst_u32(1799093319)].location_0[3]][0].location_0[unconst_u32(3906691)]; |
| return out; |
| _ = et9; |
| _ = buffer40; |
| _ = buffer44; |
| } |
| |
| @group(1) @binding(3) var et6: texture_external; |
| |
| var<workgroup> vw5: atomic<u32>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(1) @binding(0) var tex8: texture_cube_array<f32>; |
| |
| struct VertexInput12 { |
| @location(8) location_8: u32, |
| @location(2) @interpolate(flat, first) location_2: vec4h, |
| @location(5) @interpolate(flat, either) location_5: f16, |
| @location(10) location_10: vec4u, |
| @builtin(instance_index) instance_index: u32, |
| @location(14) location_14: u32, |
| @location(13) location_13: vec4u, |
| } |
| |
| struct FragmentOutput3 { |
| @location(0) location_0: vec4u, |
| } |
| |
| var<workgroup> vw6: bool; |
| |
| @group(3) @binding(436) var et9: texture_external; |
| |
| struct T1 { |
| @align(16) f0: array<array<atomic<u32>, 24>>, |
| } |
| |
| struct VertexInput14 { |
| @location(1) @interpolate(flat, center) location_1: vec2i, |
| } |
| |
| @group(3) @binding(144) var<uniform> buffer44: array<array<array<FragmentOutput3, 1>, 1>, 6>; |
| |
| struct T0 { |
| @size(122) f0: vec4f, |
| } |
| |
| struct ComputeInput4 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| @group(2) @binding(0) var<storage, read_write> buffer41: array<array<array<array<VertexInput10, 8>, 1>, 5>>; |
| |
| @group(1) @binding(37) var<storage, read_write> buffer38: array<f16, 61>; |
| |
| struct ComputeInput3 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| /* used global variables: buffer38, et6, et9, tex10, tex8 */ |
| fn fn0(a0: ptr<workgroup, atomic<u32>>) -> vec2h { |
| var out: vec2h; |
| let vf43: vec2u = textureDimensions(et6); |
| { |
| if bool(textureDimensions(tex10).y) { |
| buffer38[unconst_u32(648400216)] = f16(pack4xI8Clamp(vec4i(unconst_i32(4089361), unconst_i32(230914195), unconst_i32(321286034), unconst_i32(261159969)))); |
| let ptr36: ptr<workgroup, atomic<u32>> = &(*a0); |
| let ptr37: ptr<function, vec2h> = &out; |
| let ptr38: ptr<storage, f16, read_write> = &buffer38[unconst_u32(371976774)]; |
| _ = buffer38; |
| } |
| out = bitcast<vec2h>(atomicLoad(&(*a0))); |
| let ptr39: ptr<workgroup, atomic<u32>> = &(*a0); |
| return out; |
| _ = tex10; |
| _ = buffer38; |
| } |
| var vf44: vec2f = unpack2x16unorm(unconst_u32(1382999521)); |
| let ptr40: ptr<storage, f16, read_write> = &(*&buffer38)[60]; |
| vf44 *= vec2f(textureDimensions(et9)); |
| atomicMax(&(*a0), u32(tanh(unconst_f16(7216.5)))); |
| out = vec2h((vec3u(unconst_u32(867892588), unconst_u32(152479738), unconst_u32(1277173755)) ^ vec3u(unconst_u32(1536577019), unconst_u32(368837568), unconst_u32(446186716))).zx.xy.gg.yx.yx.xy); |
| while bool((vec3u(unconst_u32(426234311), unconst_u32(2046218800), unconst_u32(1709969126)) ^ vec3u(unconst_u32(612414100), unconst_u32(204648490), unconst_u32(3937474598)))[2]) { |
| let ptr41: ptr<storage, f16, read_write> = &(*&buffer38)[60]; |
| let vf45: ptr<storage, array<f16, 61>, read_write> = &buffer38; |
| atomicAdd(&(*a0), unconst_u32(602235563)); |
| atomicMax(&(*a0), unconst_u32(1538649860)); |
| out = vec2h((*&buffer38)[unconst_u32(430599921)]); |
| _ = buffer38; |
| } |
| for (var it3=countTrailingZeros(vec2u(unconst_u32(134785262), unconst_u32(651867600)))[1]; it3<(textureNumLevels(tex8) & 0xfff); it3++) { |
| { |
| out = vec2h(textureDimensions(tex10, unconst_i32(-195099476)).yx); |
| let vf46: vec2u = textureDimensions(tex8); |
| out -= vec2h(textureDimensions(tex8)); |
| break; |
| _ = tex8; |
| _ = tex10; |
| } |
| let vf47: vec3u = extractBits(vec3u(out.yxx), unconst_u32(784130928), unconst_u32(333678387)); |
| _ = tex8; |
| _ = tex10; |
| } |
| let vf48: vec2f = abs(vec2f(unconst_f32(0.2817), unconst_f32(0.1450e14))); |
| loop { |
| let vf49: vec2f = (unconst_f32(0.08741e25) + vec2f(unconst_f32(0.03089e-35), unconst_f32(0.01487))); |
| buffer38[unconst_u32(1662575162)] = vec2h(textureDimensions(et9))[0]; |
| var vf50: u32 = pack4xI8Clamp(vec4i(unconst_i32(226018745), unconst_i32(-613857408), unconst_i32(800569), unconst_i32(540364504))); |
| _ = et6; |
| break; |
| _ = et6; |
| _ = et9; |
| _ = buffer38; |
| } |
| return out; |
| _ = buffer38; |
| _ = et9; |
| _ = tex8; |
| _ = et6; |
| _ = tex10; |
| } |
| |
| @id(30159) override override5: i32 = 208883; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer36: array<array<array<f16, 5>, 4>, 8>; |
| |
| struct VertexInput10 { |
| @builtin(vertex_index) vertex_index: u32, |
| @location(4) @interpolate(perspective, centroid) location_4: f16, |
| } |
| |
| @group(0) @binding(70) var<uniform> buffer37: array<array<array<array<vec4u, 2>, 1>, 8>, 1>; |
| |
| @group(3) @binding(0) var tex10: texture_cube_array<f32>; |
| |
| struct VertexInput13 { |
| @location(9) @interpolate(flat, sample) location_9: vec2i, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(1) @binding(144) var<uniform> buffer40: array<vec4i, 6>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* used global variables: buffer40, buffer44, et9 */ |
| @vertex |
| fn vertex2(@location(7) @interpolate(flat, either) location_7: vec4u, a1: VertexInput10, a2: VertexInput11, @location(0) @interpolate(linear, centroid) location_0: vec2h, @location(3) @interpolate(linear, center) location_3: f16, a5: VertexInput12, a6: VertexInput13, @location(11) @interpolate(flat) location_11: vec2u, a8: VertexInput14, @location(6) location_6: vec2i) -> VertexOutput2 { |
| var out: VertexOutput2; |
| out.location_11 -= vec4i(i32(out.location_1)); |
| out.location_2 = bitcast<vec4f>(buffer40[unconst_u32(630106820)].yzyw.xywy.ragb.agbb.wywz.bgrg); |
| out.position = vec4f(buffer40[5].xxyw.aarr); |
| var vf54 = fn1(vec4<bool>(bool(a5.location_14))); |
| out.location_6 = bitcast<vec4f>(location_11.yyxy); |
| var vf55 = fn1(vec4<bool>(out.location_0.xxxx)); |
| out.location_1 = f16((*&buffer44)[5][unconst_u32(100938322)][unconst_u32(214716301)].location_0.x); |
| let ptr45: ptr<function, vec4f> = &out.location_6; |
| return out; |
| _ = et9; |
| _ = buffer44; |
| _ = buffer40; |
| } |
| |
| /* used global variables: buffer37, buffer38, buffer42, buffer44 */ |
| @fragment |
| fn fragment3(a0: FragmentInput4) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| buffer38[unconst_u32(212015240)] = f16((*&buffer37)[unconst_u32(208428873)][7][0][unconst_u32(916697559)][unconst_u32(1684433763)]); |
| buffer38[unconst_u32(341902626)] = vec4h(buffer42[15].yxxz).a; |
| let ptr46: ptr<uniform, vec4u> = &(*&buffer44)[unconst_u32(1127137096)][0][unconst_u32(361852802)].location_0; |
| let ptr47: ptr<uniform, vec4u> = &buffer44[5][unconst_u32(809668812)][0].location_0; |
| while bool((*&buffer44)[5][0][0].location_0[unconst_u32(127901613)]) { |
| out.location_0 &= vec4u(asinh(vec2h(unconst_f16(25048.0), unconst_f16(6299.3))).xyxx.rara); |
| if bool((*&buffer37)[pack4xU8(buffer37[0][7][unconst_u32(1246302121)][1])][unconst_u32(922255604)][0][1].a) { |
| let ptr48: ptr<uniform, array<array<vec4u, 2>, 1>> = &buffer37[0][unconst_u32(1107803129)]; |
| buffer38[unconst_u32(225811010)] += sin(vec2h(unconst_f16(2961.0), unconst_f16(1017.8))).x; |
| break; |
| _ = buffer38; |
| _ = buffer37; |
| } |
| break; |
| _ = buffer37; |
| _ = buffer38; |
| } |
| let ptr49: ptr<uniform, array<vec4u, 2>> = &buffer37[0][unconst_u32(1233077003)][unconst_u32(1017975539)]; |
| buffer38[unconst_u32(746446156)] *= f16(pack4xU8Clamp((*&buffer37)[0][unconst_u32(749824216)][0][1])); |
| out.location_0 = (*&buffer37)[0][unconst_u32(969736343)][unconst_u32(1462673959)][1]; |
| buffer38[60] = f16((*&buffer37)[0][7][unconst_u32(164308077)][1].a); |
| let ptr50: ptr<uniform, vec4f> = &(*&buffer42)[unconst_u32(392253200)]; |
| return out; |
| _ = buffer37; |
| _ = buffer44; |
| _ = buffer38; |
| _ = buffer42; |
| } |
| |
| /* used global variables: buffer36, buffer38, buffer41, et6, et8, et9, tex10, tex8 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute3(a0: ComputeInput3, @builtin(local_invocation_id) local_invocation_id: vec3u, a2: ComputeInput4, @builtin(global_invocation_id) global_invocation_id: vec3u) { |
| atomicCompareExchangeWeak(&vw5, unconst_u32(399197368), unconst_u32(390179032)); |
| fn0(&vw5); |
| let ptr51: ptr<storage, f16, read_write> = &(*&buffer41)[unconst_u32(4763469)][4][unconst_u32(764815513)][7].location_4; |
| var vf56 = fn0(&vw5); |
| let vf57: vec2u = textureDimensions(et8); |
| let ptr52: ptr<storage, VertexInput10, read_write> = &buffer41[unconst_u32(513747369)][unconst_u32(2734192421)][0][7]; |
| { |
| vw6 = bool((*&buffer41)[arrayLength(&(*&buffer41))][unconst_u32(394380768)][unconst_u32(261082616)][7].vertex_index); |
| let ptr53: ptr<storage, array<array<f16, 5>, 4>, read_write> = &(*&buffer36)[7]; |
| atomicXor(&vw5, unconst_u32(2229750419)); |
| let ptr54: ptr<storage, VertexInput10, read_write> = &(*&buffer41)[unconst_u32(645036444)][4][(*&buffer41)[unconst_u32(8273960)][4][0][7].vertex_index][7]; |
| atomicAdd(&vw5, u32(buffer41[unconst_u32(752972542)][unconst_u32(75355002)][0][7].location_4)); |
| buffer36[unconst_u32(876405732)][unconst_u32(460114815)][unconst_u32(450831075)] = f16(round(vec2f(unconst_f32(0.03934), unconst_f32(0.1212e28))).g); |
| _ = buffer41; |
| _ = buffer36; |
| } |
| fn0(&(*&vw5)); |
| _ = buffer41; |
| _ = tex8; |
| _ = et9; |
| _ = et8; |
| _ = et6; |
| _ = buffer36; |
| _ = tex10; |
| _ = buffer38; |
| }`, |
| }); |
| let buffer45 = device0.createBuffer({size: 76, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| let texture22 = device0.createTexture({size: [40], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST}); |
| let renderPassEncoder7 = commandEncoder19.beginRenderPass({ |
| label: '\u0563\u3478\ub550\u3b5c', |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: 996.7, g: 583.3, b: -419.3, a: 349.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer14, 'uint32', 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder(); |
| let texture23 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer15, 'uint16', 2, 25); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let texture24 = device0.createTexture({ |
| size: [60, 60, 1], |
| sampleCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture25 = device0.createTexture({ |
| size: [40, 30, 165], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer17, 12, 14); |
| } catch {} |
| let sampler3 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 70.95, |
| }); |
| try { |
| renderBundleEncoder2.setVertexBuffer(2, buffer45, 0, 1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let querySet1 = device0.createQuerySet({type: 'timestamp', count: 174}); |
| let texture26 = device0.createTexture({ |
| size: {width: 40, height: 30, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder8 = commandEncoder22.beginComputePass(); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1}); |
| let buffer46 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture27 = device0.createTexture({ |
| size: [30, 30, 1], |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder9 = commandEncoder25.beginComputePass(); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer14, 'uint32', 20, 10); |
| } catch {} |
| await gc(); |
| let textureView19 = texture8.createView({aspect: 'all'}); |
| let sampler4 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat'}); |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer45, 0); |
| } catch {} |
| try { |
| buffer15.unmap(); |
| } catch {} |
| try { |
| commandEncoder23.insertDebugMarker('\u0736'); |
| } catch {} |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 3, z: 14}, |
| aspect: 'all', |
| }, new Uint8Array(2_396).fill(86), /* required buffer size: 2_396 */ |
| {offset: 246, bytesPerRow: 34, rowsPerImage: 21}, {width: 1, height: 1, depthOrArrayLayers: 4}); |
| } catch {} |
| try { |
| adapter0.label = '\u464b\u041f\u84cf\u0551\ubbd3\ufdd9\u706e\u{1f9e0}\u0642\u022f\u{1feb5}'; |
| } catch {} |
| let texture28 = device0.createTexture({ |
| size: {width: 160, height: 120, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView20 = texture4.createView({}); |
| let renderPassEncoder8 = commandEncoder13.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -891.8, g: 810.5, b: -112.8, a: -119.5, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 657869832, |
| }); |
| try { |
| commandEncoder7.clearBuffer(buffer11); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 4, new Uint32Array(5866).map((_, i) => i * 6), 1038, 0); |
| } catch {} |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder7.beginOcclusionQuery(216); |
| } catch {} |
| try { |
| renderPassEncoder4.setBlendConstant({ r: 195.9, g: -44.76, b: 797.5, a: 1.332, }); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer45.unmap(); |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer17, 0, 129); |
| } catch {} |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(canvas0); |
| let textureView21 = texture21.createView({aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder10 = commandEncoder23.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| renderPassEncoder5.setBlendConstant({ r: -563.7, g: 159.8, b: -262.2, a: -509.0, }); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer45, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 1, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer12, 'uint16', 2, 40); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer17); |
| } catch {} |
| await gc(); |
| let renderPassEncoder9 = commandEncoder8.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: 914.0, g: 936.9, b: -825.4, a: -11.98, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 212092270, |
| }); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 82.71, |
| compare: 'not-equal', |
| maxAnisotropy: 14, |
| }); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer47 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDEX}); |
| let renderPassEncoder10 = commandEncoder14.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -482.3, g: 614.6, b: -386.0, a: 922.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 118, endOfPassWriteIndex: 81}, |
| }); |
| try { |
| await promise2; |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let computePassEncoder11 = commandEncoder28.beginComputePass(); |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer17, 'uint16', 40, 27); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer45, 0, 29); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let textureView22 = texture27.createView({}); |
| try { |
| renderBundleEncoder0.setPipeline(pipeline1); |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 1, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 64, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 630, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let buffer48 = device0.createBuffer({ |
| size: 60, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer47, 'uint16', 12, 4); |
| } catch {} |
| let buffer49 = device0.createBuffer({size: 80, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer17, 0, 12); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer14, 'uint32', 0, 10); |
| } catch {} |
| try { |
| commandEncoder20.clearBuffer(buffer26); |
| } catch {} |
| try { |
| globalThis.someLabel = buffer35.label; |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 1, resource: externalTexture0}, |
| {binding: 64, resource: textureView15}, |
| {binding: 0, resource: {buffer: buffer49}}, |
| {binding: 630, resource: textureView16}, |
| {binding: 4, resource: textureView14}, |
| ], |
| }); |
| let buffer50 = device0.createBuffer({ |
| size: 17, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let texture29 = device0.createTexture({ |
| size: {width: 60, height: 60, depthOrArrayLayers: 211}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(1114), 108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer17, 'uint16', 40, 18); |
| } catch {} |
| let imageData4 = new ImageData(28, 24); |
| let commandEncoder32 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(168), 95, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup0, new Uint32Array(1450), 176, 0); |
| } catch {} |
| let arrayBuffer0 = buffer48.getMappedRange(8, 20); |
| try { |
| commandEncoder24.copyBufferToBuffer(buffer17, 32, buffer24, 0, 4); |
| } catch {} |
| let buffer51 = device0.createBuffer({size: 28, usage: GPUBufferUsage.COPY_SRC}); |
| let texture30 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 82}, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32uint'], |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(6200), 527, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(851), 165, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(5, buffer17, 0, 7); |
| } catch {} |
| try { |
| buffer50.unmap(); |
| } catch {} |
| let texture31 = device0.createTexture({ |
| size: [160, 120, 1], |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let texture32 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder10.setVertexBuffer(6, buffer50, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(752), 164, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer14, 'uint16', 2, 2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer17, 8); |
| } catch {} |
| try { |
| renderPassEncoder6.insertDebugMarker('\u0c5e'); |
| } catch {} |
| let buffer52 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| let externalTexture1 = device0.importExternalTexture({label: '\u{1fb06}\u5660\uc055\ub01e\uec50', source: videoFrame4}); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer17, 'uint32', 8, 36); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(4, buffer50, 4); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(2496), 71, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(5, buffer48, 16); |
| } catch {} |
| let autogeneratedBindGroupLayout0 = pipeline1.getBindGroupLayout(0); |
| let textureView23 = texture1.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder12 = commandEncoder27.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 84, endOfPassWriteIndex: 159}}); |
| let sampler6 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.33, |
| maxAnisotropy: 10, |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer49, 'uint32', 52, 4); |
| } catch {} |
| let buffer53 = device0.createBuffer({ |
| size: 112, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let texture33 = device0.createTexture({ |
| size: {width: 160, height: 120, depthOrArrayLayers: 46}, |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder13 = commandEncoder7.beginComputePass(); |
| let renderPassEncoder11 = commandEncoder20.beginRenderPass({ |
| colorAttachments: [{view: textureView10, loadOp: 'clear', storeOp: 'store'}], |
| timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 152}, |
| maxDrawCount: 31019685, |
| }); |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| let promise3 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let textureView24 = texture24.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder6.beginOcclusionQuery(91); |
| } catch {} |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder7.label; |
| } catch {} |
| let texture34 = device0.createTexture({ |
| size: [15, 15, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder12 = commandEncoder33.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -289.1, g: -962.4, b: -726.3, a: 3.698, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(536), 62, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder35 = device0.createCommandEncoder(); |
| let textureView25 = texture7.createView({mipLevelCount: 1}); |
| let renderPassEncoder13 = commandEncoder30.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -981.5, g: -99.06, b: -688.9, a: 179.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 78}, |
| maxDrawCount: 332164894, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer47, 'uint32', 32, 7); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| let arrayBuffer1 = buffer48.getMappedRange(0, 0); |
| try { |
| await promise1; |
| } catch {} |
| let videoFrame5 = videoFrame3.clone(); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup0, new Uint32Array(305), 260, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.beginOcclusionQuery(74); |
| } catch {} |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer17, 0, 68); |
| } catch {} |
| let imageData5 = new ImageData(56, 32); |
| let commandEncoder37 = device0.createCommandEncoder(); |
| let textureView26 = texture18.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup0, new Uint32Array(2648), 1_141, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer15, 'uint16', 16, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 0, y: 20, z: 12}, |
| aspect: 'all', |
| }, new Uint8Array(87_992).fill(180), /* required buffer size: 87_992 */ |
| {offset: 302, bytesPerRow: 139, rowsPerImage: 31}, {width: 30, height: 11, depthOrArrayLayers: 21}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| computePassEncoder6.label = '\u2ac8\u071b\u05c8\uf771\u0aab\u{1fe74}\u{1ff24}\u5773\uc2a2'; |
| } catch {} |
| let buffer54 = device0.createBuffer({size: 780, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView27 = texture27.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 20, new Uint16Array(7921).map((_, i) => i + 5), 3996, 4); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer55 = device0.createBuffer({ |
| size: 48, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(2413), 909, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer24, 'uint16', 6, 2); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 2, y: 3, z: 35}, |
| aspect: 'all', |
| }, new Uint8Array(41_924).fill(107), /* required buffer size: 41_924 */ |
| {offset: 58, bytesPerRow: 75, rowsPerImage: 15}, {width: 2, height: 4, depthOrArrayLayers: 38}); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup0, new Uint32Array(611), 224, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(657), 113, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let textureView28 = texture0.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| let computePassEncoder14 = commandEncoder34.beginComputePass(); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(1152), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer12, 'uint16', 8, 39); |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 630, resource: textureView16}, |
| {binding: 64, resource: textureView17}, |
| {binding: 0, resource: {buffer: buffer53, size: 16}}, |
| {binding: 4, resource: textureView14}, |
| {binding: 1, resource: externalTexture1}, |
| ], |
| }); |
| let commandEncoder38 = device0.createCommandEncoder(); |
| let renderPassEncoder14 = commandEncoder37.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -296.8, g: -244.6, b: 633.6, a: 642.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 137, endOfPassWriteIndex: 100}, |
| maxDrawCount: 107043970, |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(77).fill(220), /* required buffer size: 77 */ |
| {offset: 77}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture35 = device0.createTexture({ |
| size: [160, 120, 661], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder15 = commandEncoder29.beginRenderPass({colorAttachments: [{view: textureView10, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer48, 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer17, 'uint16', 48, 7); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(22); }; |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let texture36 = device0.createTexture({ |
| size: [160], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline1); |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let textureView29 = texture35.createView({dimension: '3d', aspect: 'all'}); |
| let textureView30 = texture33.createView({baseArrayLayer: 7, arrayLayerCount: 2}); |
| let sampler7 = device0.createSampler({compare: 'less-equal'}); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup0, new Uint32Array(1662), 429, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer15, 'uint16', 70, 3); |
| } catch {} |
| try { |
| await buffer54.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| let buffer56 = device0.createBuffer({size: 56, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView31 = texture36.createView({format: 'r32uint'}); |
| try { |
| renderBundleEncoder0.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(3, buffer45); |
| } catch {} |
| let pipeline2 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2}}); |
| let imageData6 = new ImageData(8, 4); |
| let buffer57 = device0.createBuffer({size: 56, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder6.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer50, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(4, buffer55, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 4, new DataView(new Uint8Array(3450).map((_, i) => i).buffer), 311, 8); |
| } catch {} |
| try { |
| globalThis.someLabel = commandEncoder19.label; |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| {binding: 4, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 167, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 351, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 383, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let texture37 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 4}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture38 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 69}, |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder16 = commandEncoder36.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView25, |
| depthSlice: 5, |
| clearValue: { r: -652.5, g: 382.8, b: -851.6, a: -53.22, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 110, endOfPassWriteIndex: 38}, |
| maxDrawCount: 193648261, |
| }); |
| try { |
| renderBundleEncoder7.setPipeline(pipeline0); |
| } catch {} |
| await gc(); |
| let texture39 = device0.createTexture({ |
| size: {width: 128, height: 128, depthOrArrayLayers: 26}, |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture40 = device0.createTexture({ |
| size: [80, 60, 330], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer14.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let querySet2 = device0.createQuerySet({type: 'timestamp', count: 357}); |
| let textureView32 = texture37.createView({dimension: '2d'}); |
| try { |
| computePassEncoder11.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder32.resolveQuerySet(querySet0, 32, 0, buffer48, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer58 = device0.createBuffer({size: 64, usage: GPUBufferUsage.VERTEX}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder6.beginOcclusionQuery(211); |
| } catch {} |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(6, buffer45); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer24, 'uint32', 4, 7); |
| } catch {} |
| let arrayBuffer2 = buffer26.getMappedRange(0, 0); |
| let imageData7 = new ImageData(36, 36); |
| try { |
| adapter0.label = '\u2562\u00f7\u0f56\uea50\ubbea\u0a3e\u8f4d\ucbf5'; |
| } catch {} |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer45, 0, 49); |
| } catch {} |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer49, 'uint16', 42, 21); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer45, 0, 5); |
| } catch {} |
| try { |
| renderPassEncoder2.insertDebugMarker('\uf2b7'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let textureView33 = texture8.createView({}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| try { |
| computePassEncoder1.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(3506), 164, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(3, buffer17, 0, 12); |
| } catch {} |
| try { |
| commandEncoder35.resolveQuerySet(querySet0, 45, 0, buffer57, 0); |
| } catch {} |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let texture41 = device0.createTexture({ |
| label: '\ud9e4\u0385\u082c', |
| size: {width: 160, height: 120, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true, stencilReadOnly: true}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 4, new BigInt64Array(21298).map((_, i) => BigInt(i - 2)), 1822, 0); |
| } catch {} |
| let textureView34 = texture35.createView({}); |
| let texture42 = device0.createTexture({ |
| size: [160], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView35 = texture2.createView({}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder8.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(29), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer14, 'uint32', 0, 15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 4, new Float32Array(5355).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.599)), 330, 0); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder45.copyBufferToBuffer(buffer55, 0, buffer26, 0, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let texture43 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rg32uint'], |
| }); |
| let textureView36 = texture11.createView({}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup1, new Uint32Array(3657), 589, 0); |
| } catch {} |
| try { |
| buffer16.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder47 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup1, new Uint32Array(675), 159, 0); |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer15, 'uint16', 12, 18); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(5, buffer55, 16, 3); |
| } catch {} |
| document.body.prepend(canvas1); |
| let imageBitmap0 = await createImageBitmap(canvas0); |
| let imageData8 = new ImageData(32, 4); |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 5, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| {binding: 7, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 186, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture44 = device0.createTexture({ |
| size: {width: 128, height: 128, depthOrArrayLayers: 21}, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView37 = texture3.createView({baseArrayLayer: 3, arrayLayerCount: 6}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| let sampler8 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 72.16}); |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup1, new Uint32Array(91), 35, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let imageData9 = new ImageData(4, 20); |
| let texture45 = device0.createTexture({ |
| size: [160, 120, 661], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture46 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 62}, |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView38 = texture24.createView({}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(1, buffer58); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer57, 'uint32', 4, 7); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let textureView39 = texture40.createView({baseMipLevel: 2, mipLevelCount: 1}); |
| let sampler9 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.49, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup0, new Uint32Array(1066), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(181); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer50, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(3, buffer17, 12); |
| } catch {} |
| try { |
| commandEncoder18.clearBuffer(buffer55); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.STORAGE_BINDING, alphaMode: 'opaque'}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 7, y: 32, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture47 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer14, 'uint32', 4, 10); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer17, 'uint32', 48, 1); |
| } catch {} |
| let buffer59 = device0.createBuffer({ |
| size: 172, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture48 = device0.createTexture({ |
| size: [20, 15, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler10 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 12, |
| }); |
| try { |
| renderBundleEncoder6.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer49.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout1 = pipeline0.getBindGroupLayout(1); |
| let texture49 = gpuCanvasContext1.getCurrentTexture(); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder0.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer53, 0, 6); |
| } catch {} |
| try { |
| buffer15.unmap(); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 3, resource: externalTexture3}, |
| {binding: 436, resource: externalTexture4}, |
| {binding: 1, resource: textureView8}, |
| {binding: 82, resource: {buffer: buffer52}}, |
| {binding: 0, resource: textureView3}, |
| {binding: 144, resource: {buffer: buffer53}}, |
| {binding: 37, resource: {buffer: buffer59}}, |
| ], |
| }); |
| let buffer60 = device0.createBuffer({size: 48, usage: GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let textureView40 = texture17.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 12}); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup1, new Uint32Array(18), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer60, 'uint32', 4, 27); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup0, new Uint32Array(421), 18, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer57, 'uint16', 2, 20); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer50, 0, new DataView(new ArrayBuffer(5280)), 93, 0); |
| } catch {} |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let texture50 = device0.createTexture({ |
| size: [128], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder17 = commandEncoder44.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -301.2, g: -978.6, b: 765.1, a: 267.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder47.copyTextureToTexture({ |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 37, resource: {buffer: buffer59}}, |
| {binding: 436, resource: externalTexture4}, |
| {binding: 144, resource: {buffer: buffer53}}, |
| ], |
| }); |
| try { |
| computePassEncoder12.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(3, bindGroup0, new Uint32Array(2591), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer47, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup1, new Uint32Array(626), 16, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline0); |
| } catch {} |
| let buffer61 = device0.createBuffer({size: 164, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, mappedAtCreation: false}); |
| let textureView41 = texture24.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer17, 56, 38); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 5, y: 30, z: 4}, |
| aspect: 'all', |
| }, |
| {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout1]}); |
| try { |
| computePassEncoder10.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 36, new Uint32Array(12004).map((_, i) => i * 3), 4540, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout2 = pipeline1.getBindGroupLayout(0); |
| try { |
| renderPassEncoder11.insertDebugMarker('\u56f0'); |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'gamma28curve'} }); |
| let autogeneratedBindGroupLayout3 = pipeline2.getBindGroupLayout(0); |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer50, 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder16.pushDebugGroup('\u{1fa6d}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 0, new Float32Array(8768).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.748)), 4563, 0); |
| } catch {} |
| let buffer62 = device0.createBuffer({size: 60, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder51 = device0.createCommandEncoder(); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| textureView35.label = '\ub5ef\ub7d3\ub318'; |
| } catch {} |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let texture51 = device0.createTexture({ |
| size: [80, 60, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer57, 'uint32', 12); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(7, buffer50, 0); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer53}}, |
| {binding: 82, resource: {buffer: buffer62}}, |
| {binding: 0, resource: textureView3}, |
| {binding: 436, resource: externalTexture2}, |
| {binding: 37, resource: {buffer: buffer61}}, |
| {binding: 3, resource: externalTexture0}, |
| {binding: 1, resource: textureView4}, |
| ], |
| }); |
| let computePassEncoder15 = commandEncoder41.beginComputePass(); |
| try { |
| computePassEncoder15.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(3, buffer45, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let imageData10 = new ImageData(20, 212); |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 64, resource: textureView17}, |
| {binding: 1, resource: externalTexture5}, |
| {binding: 4, resource: textureView14}, |
| {binding: 0, resource: {buffer: buffer0}}, |
| {binding: 630, resource: textureView16}, |
| ], |
| }); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let texture52 = device0.createTexture({ |
| size: [160, 120, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView42 = texture47.createView({}); |
| try { |
| computePassEncoder13.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(5, buffer58, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer17, 'uint16', 136, 22); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder24.resolveQuerySet(querySet2, 13, 0, buffer53, 0); |
| } catch {} |
| let textureView43 = texture5.createView({arrayLayerCount: 1}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(7, buffer62, 0, 22); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let texture53 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup0, []); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(199); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer47, 'uint16', 20, 3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 24, new Uint32Array(23730).map((_, i) => i * 3), 1719, 0); |
| } catch {} |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let computePassEncoder16 = commandEncoder46.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 169, endOfPassWriteIndex: 94}}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer17, 0, 29); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture26, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(156).fill(137), /* required buffer size: 156 */ |
| {offset: 156}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer63 = device0.createBuffer({size: 224, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let textureView44 = texture37.createView({dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(7, buffer48, 12, 12); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder16.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(0, buffer48, 0, 29); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(2, buffer53); |
| } catch {} |
| try { |
| commandEncoder49.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 6, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 5, y: 1, z: 7}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture54 = device0.createTexture({ |
| size: [30, 30, 1], |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture55 = device0.createTexture({ |
| size: [80, 60, 330], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rg32uint'], |
| }); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| let texture56 = device0.createTexture({ |
| size: {width: 40, height: 30, depthOrArrayLayers: 49}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup4, new Uint32Array(125), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.beginOcclusionQuery(260); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer53, 4, 2); |
| } catch {} |
| let buffer64 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let textureView45 = texture2.createView({baseMipLevel: 0}); |
| let sampler11 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMinClamp: 47.65, lodMaxClamp: 59.85}); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(5, buffer48, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.insertDebugMarker('\u6d85'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 4, y: 31, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(149).fill(197), /* required buffer size: 149 */ |
| {offset: 149, bytesPerRow: 35}, {width: 3, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline3 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule3, |
| targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x4', offset: 240, shaderLocation: 6}, |
| {format: 'unorm8x4', offset: 288, shaderLocation: 7}, |
| {format: 'sint8x2', offset: 300, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 2044, shaderLocation: 0}, |
| {format: 'uint32x2', offset: 180, shaderLocation: 1}, |
| {format: 'uint8x4', offset: 420, shaderLocation: 15}, |
| {format: 'snorm16x2', offset: 20, shaderLocation: 12}, |
| {format: 'float16x2', offset: 304, shaderLocation: 3}, |
| {format: 'sint32x4', offset: 148, shaderLocation: 9}, |
| {format: 'sint32', offset: 52, shaderLocation: 8}, |
| {format: 'snorm8x2', offset: 152, shaderLocation: 14}, |
| {format: 'sint16x2', offset: 632, shaderLocation: 2}, |
| {format: 'uint32x3', offset: 116, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 16, |
| attributes: [ |
| {format: 'sint8x2', offset: 0, shaderLocation: 11}, |
| {format: 'float32x4', offset: 0, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: false}, |
| }); |
| try { |
| computePassEncoder14.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer17, 'uint32', 124, 18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 0, new Float32Array(33537).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.462)), 9899, 0); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer49, 'uint32', 4, 3); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer12, 'uint16', 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(1, buffer48, 0, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(74); }; |
| } catch {} |
| try { |
| adapter0.label = '\ufa69\u{1fa79}\u{1fb67}\uc901\u0993\u0600\u36de\u{1ffad}\u{1f79f}\u365d\ue9ff'; |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer53, offset: 0}}, |
| {binding: 436, resource: externalTexture4}, |
| {binding: 37, resource: {buffer: buffer61}}, |
| {binding: 82, resource: {buffer: buffer52}}, |
| {binding: 0, resource: textureView0}, |
| {binding: 3, resource: externalTexture3}, |
| {binding: 1, resource: textureView1}, |
| ], |
| }); |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let renderPassEncoder18 = commandEncoder42.beginRenderPass({ |
| colorAttachments: [{view: textureView39, depthSlice: 37, loadOp: 'load', storeOp: 'store'}], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 213038659, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer47, 'uint16', 14, 27); |
| } catch {} |
| let imageData11 = new ImageData(84, 8); |
| let textureView46 = texture40.createView({format: 'rg32uint', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup6, new Uint32Array(1203), 142, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(1, buffer53); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 8, new Uint32Array(12390).map((_, i) => i * 5), 12134, 0); |
| } catch {} |
| canvas0.width = 656; |
| let buffer65 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let texture57 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup3, new Uint32Array(280), 16, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 8, new Float32Array(3302).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.624)), 397, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 436, resource: externalTexture6}, |
| {binding: 37, resource: {buffer: buffer61}}, |
| {binding: 0, resource: textureView0}, |
| {binding: 82, resource: {buffer: buffer49}}, |
| {binding: 3, resource: externalTexture6}, |
| {binding: 1, resource: textureView8}, |
| {binding: 144, resource: {buffer: buffer53}}, |
| ], |
| }); |
| let buffer66 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder62 = device0.createCommandEncoder(); |
| let texture58 = device0.createTexture({ |
| size: {width: 30, height: 30, depthOrArrayLayers: 167}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView47 = texture58.createView({format: 'rg32uint', mipLevelCount: 1, baseArrayLayer: 15, arrayLayerCount: 72}); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer15, 'uint16', 8, 11); |
| } catch {} |
| await gc(); |
| let buffer67 = device0.createBuffer({size: 208, usage: GPUBufferUsage.COPY_SRC}); |
| let texture59 = device0.createTexture({ |
| size: [20, 15, 45], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup4, new Uint32Array(1345), 75, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.beginOcclusionQuery(79); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer14, 'uint16', 24, 4); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(3, bindGroup5, new Uint32Array(3004), 424, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer53); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| renderBundleEncoder4.pushDebugGroup('\ub8ff'); |
| } catch {} |
| let commandEncoder63 = device0.createCommandEncoder(); |
| let texture60 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer47, 'uint16', 28, 9); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(2, buffer58, 0, 23); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| buffer16.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder4.popDebugGroup(); |
| } catch {} |
| let imageData12 = new ImageData(104, 156); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 37, resource: {buffer: buffer61, offset: 0}}, |
| {binding: 436, resource: externalTexture2}, |
| {binding: 82, resource: {buffer: buffer52}}, |
| {binding: 0, resource: textureView3}, |
| {binding: 1, resource: textureView4}, |
| {binding: 144, resource: {buffer: buffer53}}, |
| {binding: 3, resource: externalTexture6}, |
| ], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup7, new Uint32Array(1780), 371, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| commandEncoder56.copyBufferToBuffer(buffer17, 60, buffer11, 0, 0); |
| } catch {} |
| try { |
| commandEncoder53.clearBuffer(buffer48); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 18, y: 15, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData13 = new ImageData(32, 20); |
| try { |
| externalTexture6.label = '\u14b8\ubebc\u75a3\u05f3\u6934'; |
| } catch {} |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder8.setPipeline(pipeline3); |
| } catch {} |
| let buffer68 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let textureView48 = texture34.createView({baseMipLevel: 0}); |
| let computePassEncoder17 = commandEncoder18.beginComputePass(); |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer61, 'uint16', 0, 12); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(1, buffer62); |
| } catch {} |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer15, 'uint16', 8, 0); |
| } catch {} |
| try { |
| buffer47.unmap(); |
| } catch {} |
| try { |
| commandEncoder35.copyBufferToBuffer(buffer46, 4, buffer15, 12, 8); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 630, resource: textureView16}, |
| {binding: 0, resource: {buffer: buffer14}}, |
| {binding: 4, resource: textureView14}, |
| {binding: 64, resource: textureView17}, |
| {binding: 1, resource: externalTexture4}, |
| ], |
| }); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let texture61 = device0.createTexture({ |
| size: [15, 15, 51], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView49 = texture40.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup4, new Uint32Array(523), 50, 0); |
| } catch {} |
| let buffer69 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let commandBuffer0 = commandEncoder52.finish(); |
| let textureView50 = texture42.createView({}); |
| let textureView51 = texture35.createView({}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup6, []); |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 19, y: 44, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 6, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\u8715\u078d\ua14a\ua0dc\ueb06'; |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 11, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 229, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView52 = texture61.createView({baseMipLevel: 0, baseArrayLayer: 3, arrayLayerCount: 7}); |
| let texture62 = device0.createTexture({ |
| size: [160, 120, 661], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView53 = texture1.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(6079), 2_130, 0); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let imageData14 = new ImageData(56, 4); |
| let texture63 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup9, new Uint32Array(627), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(6, buffer45); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer12, 'uint16', 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(0, buffer58, 0); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let texture64 = device0.createTexture({ |
| size: {width: 30, height: 30, depthOrArrayLayers: 12}, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder18 = commandEncoder60.beginComputePass(); |
| try { |
| device0.queue.writeBuffer(buffer65, 4, new Float32Array(2707).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.1866)), 593, 4); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer15, 'uint32', 16, 18); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 1, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 82, resource: {buffer: buffer61}}, |
| {binding: 1, resource: textureView8}, |
| {binding: 37, resource: {buffer: buffer61}}, |
| {binding: 3, resource: externalTexture6}, |
| {binding: 0, resource: textureView3}, |
| {binding: 144, resource: {buffer: buffer53, size: 101}}, |
| {binding: 436, resource: externalTexture5}, |
| ], |
| }); |
| let textureView54 = texture4.createView({mipLevelCount: 1}); |
| let computePassEncoder19 = commandEncoder66.beginComputePass(); |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer24, 'uint32', 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 436, resource: externalTexture0}, |
| {binding: 82, resource: {buffer: buffer14}}, |
| {binding: 3, resource: externalTexture4}, |
| {binding: 37, resource: {buffer: buffer59}}, |
| {binding: 144, resource: {buffer: buffer53, offset: 0}}, |
| {binding: 0, resource: textureView3}, |
| {binding: 1, resource: textureView1}, |
| ], |
| }); |
| let buffer70 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let textureView55 = texture1.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup8, []); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer12, 'uint32', 44, 6); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(6, buffer50, 0, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 4, new BigInt64Array(3103).map((_, i) => BigInt(i - 2)), 1442, 0); |
| } catch {} |
| let arrayBuffer3 = buffer48.getMappedRange(32, 4); |
| try { |
| await promise6; |
| } catch {} |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let texture65 = device0.createTexture({size: [80, 60, 330], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup2, new Uint32Array(6970), 481, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(1182); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(1, buffer53); |
| } catch {} |
| try { |
| commandEncoder38.resolveQuerySet(querySet0, 11, 23, buffer25, 256); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(1643), 155, 0); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup4, new Uint32Array(1387), 86, 0); |
| } catch {} |
| try { |
| buffer58.unmap(); |
| } catch {} |
| let textureView56 = texture15.createView({dimension: '2d', format: 'rgba8uint', baseArrayLayer: 5}); |
| let textureView57 = texture2.createView({}); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(686), 24, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(7, buffer64, 0, 0); |
| } catch {} |
| try { |
| commandEncoder59.insertDebugMarker('\u0e6b'); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 70, resource: {buffer: buffer70, size: 260}}, {binding: 1, resource: sampler7}], |
| }); |
| let buffer71 = device0.createBuffer({ |
| size: 40, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder70 = device0.createCommandEncoder(); |
| try { |
| renderBundleEncoder9.setVertexBuffer(1, buffer62, 0, 5); |
| } catch {} |
| let arrayBuffer4 = buffer48.getMappedRange(40, 0); |
| try { |
| commandEncoder32.resolveQuerySet(querySet1, 16, 0, buffer66, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 42, y: 41 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 630, resource: textureView16}, |
| {binding: 1, resource: externalTexture6}, |
| {binding: 4, resource: textureView14}, |
| {binding: 64, resource: textureView15}, |
| {binding: 0, resource: {buffer: buffer14}}, |
| ], |
| }); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer17, 'uint32', 32, 2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let texture66 = device0.createTexture({ |
| size: {width: 30}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView58 = texture31.createView({}); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup5, new Uint32Array(19), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer12, 'uint16', 6, 20); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup12); |
| } catch {} |
| let buffer72 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup8, new Uint32Array(169), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(252); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer53, 'uint32', 0, 30); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer48, 0, 10); |
| } catch {} |
| let texture67 = device0.createTexture({ |
| size: [40, 30, 165], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder19 = commandEncoder68.beginRenderPass({colorAttachments: [{view: textureView49, depthSlice: 31, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup11, new Uint32Array(695), 50, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer69, 'uint32', 8, 0); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer69, 24, new Uint32Array(2023).map((_, i) => i * 7), 380, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let textureView59 = texture37.createView({dimension: '2d'}); |
| let texture68 = device0.createTexture({size: {width: 15}, dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC}); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| commandEncoder55.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 160 */ |
| offset: 160, |
| buffer: buffer66, |
| }, { |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 4, new Uint32Array(20582).map((_, i) => i * 4), 1779, 0); |
| } catch {} |
| let textureView60 = texture15.createView({format: 'rgba8uint', baseArrayLayer: 5, arrayLayerCount: 1}); |
| let renderPassEncoder20 = commandEncoder65.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -488.3, g: 711.5, b: -953.9, a: 563.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer60, 'uint16', 10, 12); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let textureView61 = texture30.createView({dimension: '3d'}); |
| try { |
| device0.queue.writeBuffer(buffer65, 32, new BigInt64Array(4137).map((_, i) => BigInt(i - 2)), 1321, 0); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let texture69 = device0.createTexture({ |
| size: [80], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture70 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView62 = texture1.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer72, 'uint16', 18, 8); |
| } catch {} |
| try { |
| commandEncoder74.clearBuffer(buffer11); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer53}}, |
| {binding: 3, resource: externalTexture7}, |
| {binding: 82, resource: {buffer: buffer52, size: 16}}, |
| {binding: 1, resource: textureView1}, |
| {binding: 436, resource: externalTexture6}, |
| {binding: 0, resource: textureView3}, |
| {binding: 37, resource: {buffer: buffer68}}, |
| ], |
| }); |
| let buffer73 = device0.createBuffer({size: 160, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(493), 26, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 16, new DataView(new Uint8Array(9032).map((_, i) => i).buffer), 2405, 16); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer70}}, |
| {binding: 436, resource: externalTexture1}, |
| {binding: 37, resource: {buffer: buffer59}}, |
| ], |
| }); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup5, new Uint32Array(388), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup7, new Uint32Array(1207), 148, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer12, 'uint16', 20, 2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(2, buffer64, 0); |
| } catch {} |
| let textureView63 = texture5.createView({}); |
| let pipeline4 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule3, constants: {}, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALL}]}, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 176, |
| attributes: [ |
| {format: 'sint32', offset: 48, shaderLocation: 2}, |
| {format: 'float16x4', offset: 24, shaderLocation: 4}, |
| {format: 'float32', offset: 24, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 40, shaderLocation: 0}, |
| {format: 'sint8x2', offset: 4, shaderLocation: 10}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 8}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 6}, |
| {format: 'snorm16x4', offset: 52, shaderLocation: 12}, |
| {format: 'snorm8x2', offset: 22, shaderLocation: 7}, |
| {format: 'uint16x2', offset: 44, shaderLocation: 5}, |
| {format: 'sint16x4', offset: 8, shaderLocation: 11}, |
| {format: 'float32', offset: 16, shaderLocation: 3}, |
| {format: 'uint32x2', offset: 44, shaderLocation: 15}, |
| {format: 'uint8x4', offset: 28, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let bindGroup16 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer53}}, |
| {binding: 1, resource: textureView8}, |
| {binding: 82, resource: {buffer: buffer62, size: 32}}, |
| {binding: 0, resource: textureView0}, |
| {binding: 37, resource: {buffer: buffer61}}, |
| {binding: 436, resource: externalTexture7}, |
| {binding: 3, resource: externalTexture6}, |
| ], |
| }); |
| let textureView64 = texture5.createView({dimension: '2d-array'}); |
| let textureView65 = texture27.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer57, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup6); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(82, 61); |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt709', transfer: 'smpteSt4281'} }); |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 0, resource: textureView0}, |
| {binding: 144, resource: {buffer: buffer70}}, |
| {binding: 82, resource: {buffer: buffer61}}, |
| {binding: 37, resource: {buffer: buffer59}}, |
| {binding: 3, resource: externalTexture8}, |
| {binding: 1, resource: textureView8}, |
| {binding: 436, resource: externalTexture6}, |
| ], |
| }); |
| let texture71 = device0.createTexture({ |
| size: {width: 160, height: 120, depthOrArrayLayers: 661}, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder19.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup13, new Uint32Array(2431), 9, 0); |
| } catch {} |
| let arrayBuffer5 = buffer26.getMappedRange(8, 0); |
| let autogeneratedBindGroupLayout4 = pipeline4.getBindGroupLayout(2); |
| let bindGroup18 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 436, resource: externalTexture3}, |
| {binding: 0, resource: textureView0}, |
| {binding: 144, resource: {buffer: buffer73, size: 96}}, |
| {binding: 3, resource: externalTexture2}, |
| {binding: 37, resource: {buffer: buffer68}}, |
| {binding: 82, resource: {buffer: buffer52}}, |
| {binding: 1, resource: textureView62}, |
| ], |
| }); |
| let commandEncoder76 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer72, 'uint32', 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer73, 28); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 5, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(75).fill(150), /* required buffer size: 75 */ |
| {offset: 75, bytesPerRow: 30}, {width: 2, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer74 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let sampler12 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 81.11}); |
| try { |
| renderPassEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer55, 0, 12); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder58.clearBuffer(buffer70); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 1, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(23).fill(200), /* required buffer size: 23 */ |
| {offset: 23, bytesPerRow: 97}, {width: 3, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| let promise7 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule0, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA}]}, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 36, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 4, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 6}, |
| {format: 'snorm8x4', offset: 12, shaderLocation: 9}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 11}, |
| {format: 'unorm16x4', offset: 4, shaderLocation: 12}, |
| {format: 'sint16x2', offset: 4, shaderLocation: 14}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 0}, |
| {format: 'uint32', offset: 0, shaderLocation: 4}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 5}, |
| {format: 'sint32', offset: 0, shaderLocation: 8}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 2}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 3}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front'}, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup0, new Uint32Array(176), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup3, new Uint32Array(3373), 953, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer60, 'uint32', 12, 1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(2, buffer64, 0, 2); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup19 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 70, resource: {buffer: buffer70}}]}); |
| let buffer75 = device0.createBuffer({ |
| size: 460, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let textureView66 = texture11.createView({dimension: '2d-array'}); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup19, new Uint32Array(2843), 192, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setStencilReference(1898); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 14, y: 44 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup7, new Uint32Array(4451), 362, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(111); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer75, 'uint16', 20, 137); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder(); |
| let textureView67 = texture36.createView({arrayLayerCount: 1}); |
| let texture72 = device0.createTexture({ |
| size: {width: 80}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| buffer62.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer50, 0, new DataView(new ArrayBuffer(135880)), 3421, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 15, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(372).fill(172), /* required buffer size: 372 */ |
| {offset: 372, bytesPerRow: 7}, {width: 0, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData15 = new ImageData(12, 8); |
| let buffer76 = device0.createBuffer({size: 108, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer58); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let arrayBuffer6 = buffer54.getMappedRange(0, 0); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer74}}, |
| {binding: 436, resource: externalTexture3}, |
| {binding: 1, resource: textureView62}, |
| {binding: 37, resource: {buffer: buffer61}}, |
| {binding: 3, resource: externalTexture3}, |
| {binding: 82, resource: {buffer: buffer49}}, |
| {binding: 0, resource: textureView0}, |
| ], |
| }); |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer55, 0, 21); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup14, new Uint32Array(1353), 47, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let texture73 = device0.createTexture({ |
| size: [80, 60, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer12, 'uint32', 4, 46); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(0, buffer55, 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(3, buffer45); |
| } catch {} |
| let textureView68 = texture41.createView({}); |
| let sampler13 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 99.87}); |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup16, []); |
| } catch {} |
| let bindGroup21 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 70, resource: {buffer: buffer70}}, {binding: 1, resource: sampler7}], |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let texture74 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView69 = texture4.createView({baseArrayLayer: 0}); |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let pipeline5 = await promise7; |
| try { |
| offscreenCanvas0.getContext('webgl'); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 186, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture75 = device0.createTexture({size: [128, 128, 34], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer50, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 18, y: 7, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(0).fill(31), /* required buffer size: 0 */ |
| {offset: 0, bytesPerRow: 459}, {width: 55, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture5.label; |
| } catch {} |
| let textureView70 = texture17.createView({baseArrayLayer: 6, arrayLayerCount: 2}); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup2, new Uint32Array(834), 129, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup8, new Uint32Array(3620), 352, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setBlendConstant({ r: -365.7, g: 296.3, b: 466.6, a: -399.0, }); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer17, 'uint16', 14, 20); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(3, buffer17); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToBuffer({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 24, y: 52, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 112 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 16 */ |
| offset: 16, |
| bytesPerRow: 8448, |
| buffer: buffer70, |
| }, {width: 28, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(277).fill(227), /* required buffer size: 277 */ |
| {offset: 277, bytesPerRow: 65, rowsPerImage: 20}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup0, new Uint32Array(53), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer62, 0); |
| } catch {} |
| let texture76 = device0.createTexture({ |
| size: [80, 60, 330], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(331), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.insertDebugMarker('\u0866'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| externalTexture1.label = '\u3b2a\u{1f630}\u{1f7c9}'; |
| } catch {} |
| let buffer77 = device0.createBuffer({size: 612, usage: GPUBufferUsage.COPY_SRC}); |
| let texture77 = device0.createTexture({ |
| size: [120, 120, 49], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| await gc(); |
| let buffer78 = device0.createBuffer({size: 131, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let textureView71 = texture23.createView({}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup18, new Uint32Array(1023), 350, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer53, 'uint32', 0, 6); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup3, new Uint32Array(1158), 183, 0); |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 11, resource: {buffer: buffer68}}, |
| {binding: 43, resource: textureView0}, |
| {binding: 4, resource: {buffer: buffer75}}, |
| {binding: 229, resource: {buffer: buffer59}}, |
| ], |
| }); |
| let texture78 = device0.createTexture({ |
| size: [128, 128, 26], |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler14 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 88.59}); |
| try { |
| renderPassEncoder6.beginOcclusionQuery(56); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline4); |
| } catch {} |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(89, 21); |
| let textureView72 = texture38.createView({baseArrayLayer: 2, arrayLayerCount: 4}); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer17, 'uint16', 22, 20); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 4, new DataView(new Uint8Array(25744).map((_, i) => i).buffer), 7203, 4); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer17); |
| } catch {} |
| let texture79 = device0.createTexture({ |
| size: [20, 15, 82], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView73 = texture20.createView({}); |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| let textureView74 = texture21.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer61, 'uint32', 12, 53); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer55, 0, buffer70, 104, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 4, new Float32Array(44936).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5672)), 624, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup2, new Uint32Array(6054), 333, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer50); |
| } catch {} |
| try { |
| commandEncoder72.copyTextureToTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 8, y: 17, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 18, y: 5, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer79 = device0.createBuffer({size: 220, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer73, 32, 88); |
| } catch {} |
| try { |
| buffer78.unmap(); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToBuffer(buffer55, 0, buffer24, 0, 0); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| alias vec3b = vec3<bool>; |
| |
| @group(0) @binding(1) var sam6: sampler_comparison; |
| |
| struct VertexInput16 { |
| @location(9) location_9: vec2i, |
| @location(10) @interpolate(flat) location_10: u32, |
| @builtin(instance_index) instance_index: u32, |
| @location(14) location_14: vec4f, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer80: array<array<VertexInput16, 10>>; |
| |
| struct ComputeInput7 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct VertexInput17 { |
| @location(11) location_11: vec2i, |
| } |
| |
| @group(3) @binding(70) var<uniform> buffer87: array<array<array<array<array<vec4i, 4>, 1>, 1>, 1>, 4>; |
| |
| override override6 = 0.2237; |
| |
| override override7: f32; |
| |
| @id(6487) override override8: u32; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn0(a0: sampler_comparison) -> array<array<array<array<array<array<array<array<array<array<array<i32, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 45> { |
| var out: array<array<array<array<array<array<array<array<array<array<array<i32, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 1>, 45>; |
| let ptr55: ptr<function, array<i32, 1>> = &out[44][bitcast<u32>(out[unconst_u32(541684918)][0][0][0][bitcast<u32>(out[44][0][0][0][u32(out[unconst_u32(1116705545)][0][unconst_u32(388910004)][0][0][0][0][unconst_u32(1174148705)][0][0][0])][unconst_u32(1361377711)][0][0][unconst_u32(381614433)][0][0])][unconst_u32(373779242)][unconst_u32(811648541)][0][0][0][0])][0][0][0][0][0][0][unconst_u32(672577939)][unconst_u32(421724184)]; |
| vp3 = vec2i(out[unconst_u32(868255613)][unconst_u32(1220138821)][0][0][unconst_u32(543096073)][unconst_u32(275631012)][unconst_u32(1630305112)][unconst_u32(34768045)][unconst_u32(640603760)][0][unconst_u32(396506750)]); |
| let ptr56: ptr<function, i32> = &out[44][unconst_u32(3842071793)][0][unconst_u32(723951295)][unconst_u32(806492689)][0][0][unconst_u32(1129753636)][0][unconst_u32(1067230250)][unconst_u32(210042265)]; |
| let ptr57: ptr<function, i32> = &out[unconst_u32(55814843)][0][unconst_u32(998280789)][0][0][unconst_u32(1367735665)][0][unconst_u32(191867510)][0][0][unconst_u32(1010892436)]; |
| let ptr58: ptr<function, i32> = &out[unconst_u32(1179517161)][0][unconst_u32(1401323334)][unconst_u32(810407503)][unconst_u32(597975758)][0][unconst_u32(347884654)][0][unconst_u32(775546188)][0][0]; |
| for (var jj46=0u; jj46<47; jj46++) { for (var jj74=0u; jj74<3; jj74++) { out[jj46][unconst_u32(443049541)][unconst_u32(896500516)][unconst_u32(138577103)][unconst_u32(415174592)][unconst_u32(683700102)][unconst_u32(1404431679)][0][unconst_u32(156940195)][unconst_u32(515814020)][jj74] -= out[44][0][unconst_u32(73901051)][0][0][bitcast<u32>(out[44][0][unconst_u32(526760930)][0][0][unconst_u32(240539589)][0][0][0][0][0])][0][0][0][0][unconst_u32(1085062250)]; } } |
| vp3 = vec2i(out[44][0][0][unconst_u32(449954849)][0][0][0][unconst_u32(1529352405)][0][0][unconst_u32(164057968)]); |
| let ptr59: ptr<function, array<array<i32, 1>, 1>> = &out[44][0][unconst_u32(862554339)][0][0][0][0][bitcast<u32>(out[unconst_u32(961144163)][0][unconst_u32(374236127)][0][0][unconst_u32(945315410)][unconst_u32(12259572)][unconst_u32(353759247)][unconst_u32(652529535)][0][bitcast<u32>(out[unconst_u32(425440544)][0][0][unconst_u32(1210439525)][0][unconst_u32(3073765273)][0][0][0][0][0])])][bitcast<u32>(out[unconst_u32(75117406)][0][unconst_u32(351991787)][unconst_u32(149716947)][unconst_u32(211865211)][0][0][0][unconst_u32(2780774271)][0][0])]; |
| let ptr60: ptr<function, i32> = &out[unconst_u32(112164991)][unconst_u32(1357538377)][0][0][unconst_u32(427477653)][0][0][bitcast<u32>(out[unconst_u32(346790161)][0][unconst_u32(12608170)][u32(out[unconst_u32(112310767)][unconst_u32(473426544)][0][unconst_u32(193067183)][0][0][0][unconst_u32(417980985)][unconst_u32(1776718749)][0][0])][u32(out[unconst_u32(470958004)][0][unconst_u32(1269715392)][0][0][0][0][0][unconst_u32(137839665)][0][unconst_u32(202769858)])][0][unconst_u32(508241662)][unconst_u32(530645580)][0][unconst_u32(1550157044)][0])][unconst_u32(49131656)][0][0]; |
| return out; |
| } |
| |
| var<private> vp4 = array(modf(vec4h(-15756.5, 185.3, 873.2, -22896.8)), modf(vec4h(3895.8, -11610.3, 24194.7, 3039.0)), modf(vec4h(9635.5, 11587.0, 19872.1, 4220.8)), modf(vec4h(5104.4, 3661.5, 17252.2, 6707.3)), modf(vec4h(733.6, 9481.9, 9339.6, 10056.5)), modf(vec4h(9058.9, 5824.3, 6804.0, 675.9)), modf(vec4h(35750.8, 20997.6, 2262.4, 6878.3)), modf(vec4h(1282.1, 698.5, 3249.9, 14557.3)), modf(vec4h(21376.8, -11656.8, 13968.1, 9905.3)), modf(vec4h(8302.0, 13858.8, 6945.5, 37357.1)), modf(vec4h(4579.5, 12380.3, 2642.3, 7329.3)), modf(vec4h(14878.7, -1415.5, 5119.8, 841.6)), modf(vec4h(969.9, -2359.9, 4285.4, 2363.1)), modf(vec4h(14590.1, 3378.8, 14374.1, 5404.0)), modf(vec4h(3072.7, 31442.1, 28877.4, 35849.6))); |
| |
| struct FragmentOutput4 { |
| @location(0) @interpolate(flat) location_0: vec4u, |
| } |
| |
| @group(1) @binding(0) var<storage, read_write> buffer82: array<array<array<array<array<array<array<array<f16, 7>, 1>, 1>, 1>, 2>, 16>, 8>>; |
| |
| struct VertexInput15 { |
| @location(7) @interpolate(perspective) location_7: f32, |
| } |
| |
| @group(2) @binding(115) var st2: texture_storage_2d<r32float, read_write>; |
| |
| @id(52277) override override9: f16; |
| |
| var<workgroup> vw7: array<atomic<u32>, 1>; |
| |
| @group(3) @binding(0) var<storage, read_write> buffer86: array<array<FragmentInput6, 40>>; |
| |
| struct FragmentInput7 { |
| @builtin(position) position: vec4f, |
| } |
| |
| struct FragmentInput6 { |
| @location(13) location_13: vec2u, |
| } |
| |
| struct VertexOutput3 { |
| @location(1) location_1: f32, |
| @location(4) location_4: vec4f, |
| @location(0) location_0: vec4u, |
| @location(10) location_10: vec4h, |
| @location(9) location_9: f16, |
| @location(2) @interpolate(linear, either) location_2: f32, |
| @location(15) @interpolate(perspective, first) location_15: vec2h, |
| @builtin(position) position: vec4f, |
| @location(11) @interpolate(flat, first) location_11: vec4h, |
| @location(14) @interpolate(flat, centroid) location_14: i32, |
| @location(3) location_3: vec2i, |
| @location(7) location_7: vec2f, |
| @location(5) location_5: vec2f, |
| @location(6) location_6: vec2f, |
| } |
| |
| struct ComputeInput5 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| @group(1) @binding(115) var st1: texture_storage_2d<r32float, read_write>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(3) @binding(1) var sam7: sampler_comparison; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp3: vec2i = vec2i(476470049, 88725049); |
| |
| @group(2) @binding(10) var<storage, read_write> buffer85: vec4h; |
| |
| struct ComputeInput6 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(2) @binding(0) var<storage, read_write> buffer84: array<array<array<f32, 56>, 16>>; |
| |
| struct FragmentInput5 { |
| @location(8) location_8: vec4h, |
| } |
| |
| struct T0 { |
| f0: array<array<atomic<u32>, 2>>, |
| } |
| |
| /* used global variables: sam6, sam7 */ |
| @vertex |
| fn vertex3(@location(1) @interpolate(perspective, either) location_1: f32, a1: VertexInput15, a2: VertexInput16, @location(12) location_12: f32, a4: VertexInput17, @location(8) location_8: f32, @location(4) @interpolate(flat) location_4: u32, @location(15) location_15: u32, @location(5) @interpolate(flat, either) location_5: vec2u) -> VertexOutput3 { |
| var out: VertexOutput3; |
| _ = fn0(sam6); |
| out.position = vec4f(f32(out.location_9)); |
| out.position -= vec4f(bitcast<f32>(a2.instance_index)); |
| out.position = vec4f(vp4[unconst_u32(1392986337)].fract.wzxw.brag); |
| _ = fn0(sam6); |
| var vf58: f32 = location_8; |
| var vf59 = fn0(sam7); |
| var vf60 = fn0(sam7); |
| let ptr61: ptr<function, array<array<i32, 1>, 1>> = &vf60[44][0][unconst_u32(473035466)][unconst_u32(644333768)][unconst_u32(681277804)][0][unconst_u32(55112381)][bitcast<u32>(vf59[44][0][0][0][bitcast<u32>(vf60[unconst_u32(24952847)][0][unconst_u32(346677716)][unconst_u32(717980754)][0][unconst_u32(618698950)][0][unconst_u32(228883160)][0][0][0])][0][unconst_u32(62742736)][0][unconst_u32(240440457)][0][0])][0]; |
| out.location_6 -= vec2f(bitcast<f32>(vf60[unconst_u32(87398397)][unconst_u32(126191222)][unconst_u32(135775691)][0][unconst_u32(316034854)][0][0][unconst_u32(1301287074)][unconst_u32(493870365)][unconst_u32(3932274131)][0])); |
| return out; |
| _ = sam7; |
| _ = sam6; |
| } |
| |
| /* used global variables: buffer82, buffer84, buffer87, st1, st2 */ |
| @fragment |
| fn fragment4(a0: FragmentInput5, @location(6) location_6: vec2h, a2: FragmentInput6, a3: FragmentInput7) -> @location(200) vec2u { |
| var out: vec2u; |
| vp4[unconst_u32(583360954)] = modf(vec4h(buffer82[arrayLength(&buffer82)][7][unconst_u32(2016027560)][unconst_u32(1211671537)][unconst_u32(349644494)][unconst_u32(75316007)][unconst_u32(348256957)][6])); |
| textureStore(st2, vec2i(unconst_i32(756619699), unconst_i32(-245930981)), vec4f(vec4f(unconst_f32(0.03875e20), unconst_f32(0.1109), unconst_f32(0.1543), unconst_f32(0.5266)))); |
| textureStore(st1, vec2i(unconst_i32(630264849), unconst_i32(-337048747)), vec4f(vec4f(unconst_f32(0.1466), unconst_f32(0.6519), unconst_f32(0.08014), unconst_f32(0.1471)))); |
| textureStore(st2, vec2i(unconst_i32(641589395), unconst_i32(498720836)), vec4f(vec4f(unconst_f32(0.02645e3), unconst_f32(0.00494), unconst_f32(0.1083), unconst_f32(0.3790e-34)))); |
| let ptr62: ptr<storage, f16, read_write> = &buffer82[unconst_u32(1340899488)][unconst_u32(464413715)][15][1][unconst_u32(3839786015)][unconst_u32(129087616)][unconst_u32(499604685)][6]; |
| buffer84[unconst_u32(777256534)][unconst_u32(471107085)][unconst_u32(550996947)] = f32((*&buffer82)[arrayLength(&(*&buffer82))][7][15][unconst_u32(2195230691)][unconst_u32(301642691)][0][unconst_u32(180599116)][6]); |
| vp4[unconst_u32(888648689)].fract = vec4h(buffer82[unconst_u32(1010159498)][7][unconst_u32(93686754)][1][0][unconst_u32(143966828)][0][unconst_u32(390382326)]); |
| for (var jj31=0u; jj31<17; jj31++) { vp4[jj31].fract -= vec4h((*&buffer87)[unconst_u32(8480968)][0][0][unconst_u32(134068406)][3].agra); } |
| let ptr63: ptr<storage, f16, read_write> = &(*&buffer82)[unconst_u32(510091074)][7][unconst_u32(929766856)][1][0][unconst_u32(84618595)][unconst_u32(995205624)][unconst_u32(1346407779)]; |
| return out; |
| _ = buffer84; |
| _ = buffer82; |
| _ = st2; |
| _ = buffer87; |
| _ = st1; |
| } |
| |
| /* used global variables: st1 */ |
| @fragment |
| fn fragment5(@location(8) location_8: vec4h) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| textureStore(st1, vec2i(unconst_i32(-1475077788), unconst_i32(1207828414)), vec4f(vec4f(unconst_f32(0.3207), unconst_f32(0.09433), unconst_f32(0.01632e-38), unconst_f32(0.09034)))); |
| return out; |
| _ = st1; |
| } |
| |
| /* used global variables: buffer80, buffer82, buffer84, buffer85, buffer86 */ |
| @compute @workgroup_size(2, 1, 2) |
| fn compute4(a0: ComputeInput5, a1: ComputeInput6, a2: ComputeInput7, @builtin(local_invocation_id) local_invocation_id: vec3u) { |
| let ptr64: ptr<storage, f16, read_write> = &buffer82[unconst_u32(215395417)][unconst_u32(783895882)][15][unconst_u32(3605420)][unconst_u32(2407348738)][unconst_u32(381368759)][unconst_u32(118173653)][unconst_u32(46217733)]; |
| buffer80[unconst_u32(316293348)][unconst_u32(898509075)].location_10 = u32((*&buffer82)[arrayLength(&(*&buffer82))][unconst_u32(732073061)][unconst_u32(2111202538)][unconst_u32(984071908)][0][0][0][6]); |
| buffer80[unconst_u32(190602286)][unconst_u32(1733135935)] = VertexInput16(vec2i(i32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6])), u32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6]), u32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6]), vec4f(f32(buffer82[unconst_u32(2322400479)][bitcast<u32>(buffer84[unconst_u32(215527832)][(*&buffer86)[arrayLength(&(*&buffer86))][39].location_13.y][55])][unconst_u32(79982675)][1][0][unconst_u32(52111796)][0][6]))); |
| let ptr65: ptr<storage, array<array<array<array<f16, 7>, 1>, 1>, 1>, read_write> = &buffer82[arrayLength(&buffer82)][unconst_u32(1198300002)][u32(buffer82[unconst_u32(96899402)][unconst_u32(621829244)][15][unconst_u32(1134023491)][unconst_u32(1679787384)][0][unconst_u32(578914107)][unconst_u32(361638586)])][unconst_u32(183935487)]; |
| buffer85 -= vec4h(buffer82[unconst_u32(503343278)][u32((*ptr65)[unconst_u32(115807681)][unconst_u32(629816108)][unconst_u32(87015105)][unconst_u32(1031263185)])][unconst_u32(2611630161)][1][0][u32(buffer82[u32(buffer82[unconst_u32(253226650)][7][15][1][0][0][unconst_u32(684670342)][6])][7][15][1][0][0][0][6])][0][6]); |
| let ptr66: ptr<storage, array<f16, 7>, read_write> = &buffer82[unconst_u32(434656994)][7][15][unconst_u32(1243041098)][unconst_u32(468351122)][unconst_u32(289613960)][0]; |
| let ptr67: ptr<storage, array<array<array<array<array<f16, 7>, 1>, 1>, 1>, 2>, read_write> = &(*&buffer82)[arrayLength(&(*&buffer82))][7][unconst_u32(708933806)]; |
| buffer84[unconst_u32(737821132)][15][unconst_u32(810257902)] = f32(buffer82[arrayLength(&buffer82)][7][unconst_u32(366394740)][unconst_u32(1373327066)][0][0][0][6]); |
| vp4[unconst_u32(363480935)] = modf(vec4h((*&buffer82)[arrayLength(&(*&buffer82))][unconst_u32(529093787)][unconst_u32(514804187)][1][0][0][0][unconst_u32(146819301)])); |
| vp3 = vec2i(i32(buffer82[unconst_u32(2211035613)][7][15][1][unconst_u32(1212917309)][0][0][6])); |
| let ptr68: ptr<storage, f16, read_write> = &buffer82[arrayLength(&buffer82)][7][unconst_u32(642866192)][1][unconst_u32(226050851)][0][0][unconst_u32(34741308)]; |
| let ptr69: ptr<storage, f32, read_write> = &(*&buffer84)[arrayLength(&(*&buffer84))][15][unconst_u32(1286148924)]; |
| _ = buffer84; |
| _ = buffer82; |
| _ = buffer86; |
| _ = buffer80; |
| _ = buffer85; |
| }`, |
| }); |
| let bindGroup23 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 1, resource: sampler2}, {binding: 70, resource: {buffer: buffer70, size: 260}}], |
| }); |
| let buffer88 = device0.createBuffer({size: 184, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let sampler15 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 90.17, |
| maxAnisotropy: 1, |
| }); |
| try { |
| buffer14.unmap(); |
| } catch {} |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let texture80 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 138}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView75 = texture11.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder6.setVertexBuffer(1, buffer63, 0, 84); |
| } catch {} |
| try { |
| commandEncoder72.copyBufferToBuffer(buffer75, 28, buffer59, 8, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer69, 56, new Float32Array(15998).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.399)), 51, 0); |
| } catch {} |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let textureView76 = texture45.createView({}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup0, new Uint32Array(2655), 157, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup2, new Uint32Array(410), 188, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let textureView77 = texture61.createView({baseMipLevel: 0, baseArrayLayer: 11, arrayLayerCount: 8}); |
| let texture81 = device0.createTexture({ |
| size: [60, 60, 24], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32uint'], |
| }); |
| let textureView78 = texture38.createView({dimension: 'cube-array', baseArrayLayer: 13, arrayLayerCount: 12}); |
| let computePassEncoder20 = commandEncoder62.beginComputePass(); |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| let arrayBuffer7 = buffer48.getMappedRange(48, 0); |
| try { |
| device0.queue.writeBuffer(buffer15, 0, new Float16Array(10593).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.078)), 1376, 8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(60).fill(108), /* required buffer size: 60 */ |
| {offset: 60, bytesPerRow: 34}, {width: 1, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView79 = texture15.createView({dimension: '2d', format: 'rgba8uint', mipLevelCount: 1, baseArrayLayer: 7}); |
| let textureView80 = texture16.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer15, 'uint32', 40, 1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer60, 'uint16', 4, 25); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu'); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(53); }; |
| } catch {} |
| let imageData16 = new ImageData(16, 4); |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 186, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 436, resource: externalTexture7}, |
| {binding: 144, resource: {buffer: buffer73, offset: 0}}, |
| {binding: 37, resource: {buffer: buffer75}}, |
| ], |
| }); |
| let texture82 = device0.createTexture({ |
| size: [60], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView81 = texture63.createView({}); |
| try { |
| renderPassEncoder19.setVertexBuffer(0, buffer45, 4, 15); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| let bindGroup25 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 70, resource: {buffer: buffer70}}, {binding: 1, resource: sampler2}], |
| }); |
| let texture83 = device0.createTexture({ |
| size: [120, 120, 49], |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder21 = commandEncoder55.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup19); |
| } catch {} |
| let pipeline6 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule0, targets: [{format: 'rg32uint', writeMask: GPUColorWrite.RED}]}, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 80, |
| attributes: [ |
| {format: 'sint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'float16x4', offset: 52, shaderLocation: 8}, |
| {format: 'uint32', offset: 4, shaderLocation: 15}, |
| {format: 'float32', offset: 8, shaderLocation: 7}, |
| {format: 'sint8x2', offset: 26, shaderLocation: 11}, |
| {format: 'uint32x4', offset: 4, shaderLocation: 4}, |
| {format: 'float32x4', offset: 20, shaderLocation: 1}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 12, shaderLocation: 5}, |
| {format: 'uint32', offset: 4, shaderLocation: 10}, |
| {format: 'float32x4', offset: 4, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front'}, |
| }); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let texture84 = device0.createTexture({ |
| size: {width: 30, height: 30, depthOrArrayLayers: 12}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup6); |
| } catch {} |
| await gc(); |
| let bindGroup26 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer53}}, |
| {binding: 37, resource: {buffer: buffer68}}, |
| {binding: 436, resource: externalTexture2}, |
| ], |
| }); |
| let textureView82 = texture82.createView({}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer75, 'uint32', 20, 226); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let texture85 = device0.createTexture({ |
| size: [20, 15, 82], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture86 = device0.createTexture({ |
| size: [120], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| await promise8; |
| } catch {} |
| let commandEncoder90 = device0.createCommandEncoder(); |
| let texture87 = device0.createTexture({ |
| size: [30, 30, 12], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| externalTexture6.label = '\u0181\u{1fd3d}\udf0e'; |
| } catch {} |
| let buffer89 = device0.createBuffer({size: 452, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let textureView83 = texture83.createView({dimension: '3d'}); |
| let textureView84 = texture35.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer72, 'uint32', 12, 13); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer58, 0, 9); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer12, 'uint16', 0, 3); |
| } catch {} |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let texture88 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 82}, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup23, new Uint32Array(1850), 539, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder49.copyBufferToBuffer(buffer54, 184, buffer64, 0, 0); |
| } catch {} |
| try { |
| commandEncoder79.copyBufferToTexture({ |
| /* bytesInLastRow: 176 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 576 */ |
| offset: 576, |
| rowsPerImage: 320, |
| buffer: buffer77, |
| }, { |
| texture: texture86, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToTexture({ |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 32}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 24, y: 1, z: 26}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 8, new DataView(new Uint8Array(1897).map((_, i) => i).buffer), 178, 8); |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte240m', transfer: 'bt2020_12bit'} }); |
| let texture89 = device0.createTexture({ |
| size: [60, 60, 24], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup6, new Uint32Array(830), 310, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(27); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer73, 0, 27); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(3, bindGroup13); |
| } catch {} |
| let textureView85 = texture88.createView({}); |
| let texture90 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder17.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup9, []); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup2, new Uint32Array(5226), 1_752, 0); |
| } catch {} |
| try { |
| buffer76.unmap(); |
| } catch {} |
| try { |
| commandEncoder80.resolveQuerySet(querySet1, 23, 0, buffer74, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout5 = pipeline3.getBindGroupLayout(2); |
| let texture91 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder1.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer59, 64, new Uint32Array(2072).map((_, i) => i * 7), 484, 12); |
| } catch {} |
| try { |
| externalTexture0.label = '\u0640\u3816\u56de\u084b'; |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup15, new Uint32Array(1943), 148, 0); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let texture92 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 6}, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer60, 'uint16', 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline6); |
| } catch {} |
| let texture93 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 82}, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView86 = texture68.createView({}); |
| let computePassEncoder22 = commandEncoder72.beginComputePass(); |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let buffer90 = device0.createBuffer({size: 196, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline2); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 180, y: 32 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 55, y: 16, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 10, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup24, new Uint32Array(33), 5, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(1, buffer73, 0, 22); |
| } catch {} |
| try { |
| buffer65.unmap(); |
| } catch {} |
| let texture94 = device0.createTexture({size: [128, 128, 126], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup19, new Uint32Array(865), 30, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline5); |
| } catch {} |
| let texture95 = device0.createTexture({ |
| size: [120], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer57, 'uint16', 56); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToTexture({ |
| texture: texture76, |
| mipLevel: 0, |
| origin: {x: 1, y: 5, z: 17}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 15, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 16, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let texture96 = device0.createTexture({ |
| size: {width: 60, height: 60, depthOrArrayLayers: 30}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer61, 'uint16', 32, 8); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer48, 0, 14); |
| } catch {} |
| try { |
| buffer49.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline7 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| buffers: [ |
| { |
| arrayStride: 52, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32', offset: 0, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 20, shaderLocation: 5}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 2}, |
| {format: 'uint8x4', offset: 8, shaderLocation: 7}, |
| {format: 'sint8x4', offset: 48, shaderLocation: 6}, |
| {format: 'uint8x2', offset: 18, shaderLocation: 13}, |
| {format: 'snorm8x4', offset: 8, shaderLocation: 0}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 15}, |
| {format: 'float16x4', offset: 0, shaderLocation: 4}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 1}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 11}, |
| ], |
| }, |
| {arrayStride: 72, attributes: [{format: 'uint32', offset: 12, shaderLocation: 10}]}, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| try { |
| externalTexture2.label = '\uffc5\u2836\u6e5e\u69a3\u7294\u{1ff28}\u07f2\udbf9\u5f06'; |
| } catch {} |
| let bindGroup27 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer68}}, |
| {binding: 11, resource: {buffer: buffer49}}, |
| {binding: 229, resource: {buffer: buffer61}}, |
| {binding: 43, resource: textureView3}, |
| ], |
| }); |
| let buffer91 = device0.createBuffer({size: 315, usage: GPUBufferUsage.INDIRECT}); |
| let textureView87 = texture83.createView({}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| try { |
| renderBundleEncoder18.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(4, buffer79, 0, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData15, |
| origin: { x: 5, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let textureView88 = texture93.createView({}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer62, 0, buffer64, 4, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer70, 48, new Uint32Array(21390).map((_, i) => i * 2), 5993, 28); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 2, y: 3, z: 85}, |
| aspect: 'all', |
| }, new Uint8Array(4_152_415).fill(3), /* required buffer size: 4_152_415 */ |
| {offset: 449, bytesPerRow: 119, rowsPerImage: 141}, {width: 7, height: 64, depthOrArrayLayers: 248}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 4, y: 30 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 7, y: 13, z: 10}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 41, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(15); }; |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer92 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer63, 0, 3); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup28 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 70, resource: {buffer: buffer70}}]}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup13); |
| } catch {} |
| let buffer93 = device0.createBuffer({size: 536, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| commandEncoder63.copyTextureToTexture({ |
| texture: texture28, |
| mipLevel: 3, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture67, |
| mipLevel: 1, |
| origin: {x: 0, y: 6, z: 24}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder97 = device0.createCommandEncoder(); |
| let texture97 = device0.createTexture({ |
| size: {width: 120}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: false}); |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup5, new Uint32Array(1286), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer47, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(1, buffer79, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup20, new Uint32Array(3482), 115, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(2, buffer75); |
| } catch {} |
| try { |
| buffer88.unmap(); |
| } catch {} |
| let imageData17 = new ImageData(24, 4); |
| let textureView89 = texture65.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup7, new Uint32Array(526), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer15, 'uint32', 8, 8); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer55, 0, 17); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 73, y: 14 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let buffer94 = device0.createBuffer({size: 3064, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(4, buffer50, 0); |
| } catch {} |
| let imageData18 = new ImageData(72, 32); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup15, new Uint32Array(1037), 161, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(543).fill(76), /* required buffer size: 543 */ |
| {offset: 543, bytesPerRow: 348, rowsPerImage: 30}, {width: 28, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 1, resource: sampler2}, {binding: 70, resource: {buffer: buffer70}}], |
| }); |
| let texture98 = device0.createTexture({ |
| size: [128, 128, 26], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| buffer78.unmap(); |
| } catch {} |
| try { |
| commandEncoder88.pushDebugGroup('\u4fff'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 0, new Uint32Array(14333).map((_, i) => i * 9), 1995, 0); |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder(); |
| let texture99 = device0.createTexture({ |
| size: {width: 128, height: 128, depthOrArrayLayers: 26}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer89, 'uint16', 52, 86); |
| } catch {} |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder8.insertDebugMarker('\u3e81'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture2.label; |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder(); |
| let texture100 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder21 = commandEncoder70.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView68, |
| clearValue: { r: -195.4, g: -543.6, b: -228.5, a: -450.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup11, new Uint32Array(264), 35, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup22, new Uint32Array(124), 1, 1); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(2, buffer50, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 0, new BigInt64Array(34443).map((_, i) => BigInt(i - 8)), 14180, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData15, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let texture101 = device0.createTexture({ |
| size: {width: 160}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline6); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 92.79, |
| compare: 'greater', |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(2, bindGroup2, []); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer47, 'uint16', 20, 23); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup29); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder69.clearBuffer(buffer55, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture88, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(10_570).fill(102), /* required buffer size: 10_570 */ |
| {offset: 13, bytesPerRow: 207, rowsPerImage: 3}, {width: 11, height: 0, depthOrArrayLayers: 18}); |
| } catch {} |
| let commandEncoder104 = device0.createCommandEncoder(); |
| let texture102 = device0.createTexture({ |
| size: [15, 15, 38], |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView90 = texture47.createView({aspect: 'all'}); |
| let computePassEncoder23 = commandEncoder87.beginComputePass(); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(videoFrame0); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer45); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup4, new Uint32Array(760), 72, 0); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture9.label; |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 3, resource: externalTexture5}, |
| {binding: 436, resource: externalTexture1}, |
| {binding: 1, resource: textureView4}, |
| {binding: 82, resource: {buffer: buffer49}}, |
| {binding: 37, resource: {buffer: buffer88}}, |
| {binding: 144, resource: {buffer: buffer73, offset: 0}}, |
| {binding: 0, resource: textureView0}, |
| ], |
| }); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| let textureView91 = texture35.createView({format: 'r32sint'}); |
| let sampler17 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 93.46, |
| lodMaxClamp: 93.47, |
| }); |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup29); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder91.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 6, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture96, |
| mipLevel: 0, |
| origin: {x: 5, y: 12, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer95 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer69, 'uint16', 4, 49); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer72, 'uint16', 6, 1); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToBuffer(buffer59, 0, buffer11, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer94, 224, new Uint32Array(6245).map((_, i) => i * 1), 577, 104); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData15, |
| origin: { x: 1, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder6.beginOcclusionQuery(90); |
| } catch {} |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup29, new Uint32Array(1553), 398, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(6, buffer17, 40); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(110); }; |
| } catch {} |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder18.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer62); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer60, 'uint32', 4, 6); |
| } catch {} |
| try { |
| commandEncoder88.popDebugGroup(); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder(); |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer57, 'uint16', 2, 8); |
| } catch {} |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let texture103 = device0.createTexture({ |
| size: {width: 30}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rg32float'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup27, new Uint32Array(379), 162, 1); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(3, buffer53, 0, 16); |
| } catch {} |
| try { |
| commandEncoder86.copyBufferToBuffer(buffer55, 24, buffer70, 0, 0); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet0, 40, 0, buffer48, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 0, y: 19, z: 15}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 122, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 123, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 256, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 325, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 372, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout6 = pipeline8.getBindGroupLayout(0); |
| let buffer96 = device0.createBuffer({size: 50, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let textureView92 = texture103.createView({arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder9.setVertexBuffer(3, buffer58); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(6); }; |
| } catch {} |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer24, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup15, new Uint32Array(48), 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer12, 'uint32', 44, 27); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(3, buffer58); |
| } catch {} |
| try { |
| renderPassEncoder12.label = '\uaeab\u881f\u0867\u0f79\u{1fd05}\ue959\u84f4\u9570\u0fb3\u1719\u{1fb74}'; |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder35.copyBufferToBuffer(buffer75, 112, buffer69, 20, 20); |
| } catch {} |
| try { |
| commandEncoder81.copyTextureToTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder(); |
| let sampler18 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', magFilter: 'linear', lodMaxClamp: 98.77}); |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup4, new Uint32Array(316), 32, 0); |
| } catch {} |
| try { |
| commandEncoder84.resolveQuerySet(querySet1, 5, 1, buffer96, 0); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(95); }; |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let bindGroup31 = device0.createBindGroup({ |
| label: '\u438f\u{1f652}\u0cc5', |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 82, resource: {buffer: buffer76}}, |
| {binding: 144, resource: {buffer: buffer73}}, |
| {binding: 0, resource: textureView3}, |
| {binding: 3, resource: externalTexture6}, |
| {binding: 37, resource: {buffer: buffer68}}, |
| {binding: 1, resource: textureView55}, |
| {binding: 436, resource: externalTexture2}, |
| ], |
| }); |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let texture104 = device0.createTexture({ |
| size: [160, 120, 661], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView93 = texture29.createView({baseArrayLayer: 27, arrayLayerCount: 8}); |
| let computePassEncoder24 = commandEncoder79.beginComputePass(); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer92); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 10, y: 25 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 5, y: 16, z: 9}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 9, height: 43, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer97 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| let textureView94 = texture78.createView({dimension: 'cube', baseArrayLayer: 1}); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer72, 'uint16', 6, 10); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer61.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let pipeline10 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let autogeneratedBindGroupLayout7 = pipeline3.getBindGroupLayout(3); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| renderBundleEncoder13.insertDebugMarker('\u08a1'); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer75}}, |
| {binding: 4, resource: textureView60}, |
| {binding: 630, resource: textureView16}, |
| {binding: 1, resource: externalTexture8}, |
| {binding: 64, resource: textureView17}, |
| ], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup28, new Uint32Array(760), 540, 0); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(1746), 400, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer61, 'uint32', 12, 12); |
| } catch {} |
| try { |
| commandEncoder82.copyTextureToTexture({ |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 4, y: 11, z: 10}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder17.pushDebugGroup('\u00eb'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 27, y: 65 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 17, y: 30, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(4); }; |
| } catch {} |
| let texture105 = device0.createTexture({ |
| size: {width: 40, height: 30, depthOrArrayLayers: 53}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder16.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(96); }; |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(15, 416); |
| let buffer98 = device0.createBuffer({size: 608, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let texture106 = device0.createTexture({ |
| size: [160, 120, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture107 = device0.createTexture({size: [60, 60, 24], dimension: '3d', format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder6.beginOcclusionQuery(109); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(5, buffer64, 0, 6); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| document.body.prepend(canvas1); |
| let texture108 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 49}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder4.beginOcclusionQuery(12); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer60, 'uint16', 18, 1); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let textureView95 = texture12.createView({ |
| label: '\u001e\u{1f975}\u02e2\u02b9\udde3\u0228\u4394\u0b36', |
| dimension: '2d-array', |
| aspect: 'all', |
| baseMipLevel: 0, |
| arrayLayerCount: 1, |
| }); |
| let texture109 = device0.createTexture({ |
| size: [80, 60, 1], |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView96 = texture30.createView({}); |
| let sampler19 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 45.26, |
| lodMaxClamp: 60.98, |
| compare: 'equal', |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder17.popDebugGroup(); |
| } catch {} |
| try { |
| renderPassEncoder4.insertDebugMarker('\u553a'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer93, 20, new Float32Array(652).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8610)), 6, 32); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(2); }; |
| } catch {} |
| let buffer99 = device0.createBuffer({size: 327, usage: GPUBufferUsage.UNIFORM}); |
| let textureView97 = texture106.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let textureView98 = texture12.createView({format: 'rg11b10ufloat', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer15, 'uint32', 16, 30); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline1); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let imageData19 = new ImageData(8, 128); |
| let textureView99 = texture108.createView({dimension: '3d'}); |
| let texture110 = device0.createTexture({ |
| size: [120, 120, 34], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder25 = commandEncoder85.beginComputePass({timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 3}}); |
| try { |
| renderBundleEncoder18.setBindGroup(2, bindGroup24, new Uint32Array(233), 5, 0); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer46, 0, buffer72, 8, 8); |
| } catch {} |
| let pipeline11 = await promise3; |
| try { |
| adapter0.label = '\uc904\u0cfd\u{1fc1a}\u0c33\u{1fece}\uc62f\u2d34\u{1f79f}'; |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let texture111 = device0.createTexture({ |
| size: [40], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup12, []); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline12 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| buffers: [ |
| { |
| arrayStride: 664, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint8x4', offset: 32, shaderLocation: 11}, |
| {format: 'unorm16x2', offset: 136, shaderLocation: 2}, |
| {format: 'sint32', offset: 104, shaderLocation: 14}, |
| {format: 'uint32x2', offset: 8, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 36, shaderLocation: 0}, |
| {format: 'snorm16x4', offset: 52, shaderLocation: 6}, |
| {format: 'snorm16x4', offset: 88, shaderLocation: 10}, |
| {format: 'sint8x4', offset: 8, shaderLocation: 3}, |
| {format: 'sint32x4', offset: 32, shaderLocation: 8}, |
| {format: 'uint8x4', offset: 56, shaderLocation: 4}, |
| {format: 'float32x2', offset: 36, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 208, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9}, |
| {format: 'sint32x4', offset: 40, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let gpuCanvasContext3 = offscreenCanvas2.getContext('webgpu'); |
| let img0 = await imageWithData(43, 26, '#10101010', '#20202020'); |
| let autogeneratedBindGroupLayout8 = pipeline9.getBindGroupLayout(1); |
| let texture112 = device0.createTexture({ |
| size: {width: 160}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder25.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let adapter1 = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'}); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 37, resource: {buffer: buffer88}}, |
| {binding: 436, resource: externalTexture4}, |
| {binding: 144, resource: {buffer: buffer88}}, |
| ], |
| }); |
| let textureView100 = texture111.createView({}); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer60, 'uint32', 4, 4); |
| } catch {} |
| try { |
| commandEncoder61.clearBuffer(buffer97); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| let buffer100 = device0.createBuffer({size: 228, usage: GPUBufferUsage.INDIRECT}); |
| let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| document.body.prepend(canvas0); |
| offscreenCanvas2.width = 1208; |
| let texture113 = device0.createTexture({size: [60], dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_DST}); |
| let textureView101 = texture5.createView({arrayLayerCount: 1}); |
| let renderPassEncoder22 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView80, |
| clearValue: { r: -347.8, g: -154.2, b: -74.79, a: 283.2, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 411999850, |
| }); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer76, 'uint32', 16, 35); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 536 */ |
| offset: 536, |
| bytesPerRow: 11520, |
| buffer: buffer77, |
| }, { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 12, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 13, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture8.label = '\u05cf\u88e3\u{1f9d3}\u8b2d'; |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup5, new Uint32Array(1585), 42, 0); |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(2, buffer64, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: imageData15, |
| origin: { x: 6, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 3, y: 9, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout9 = pipeline11.getBindGroupLayout(1); |
| let texture114 = device0.createTexture({ |
| label: '\u3de0\u079b\u3dc4\u576b\u093d\u567e\u{1fb9c}', |
| size: {width: 80, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView102 = texture109.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer89, 'uint16', 102, 133); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer47, 'uint16', 26, 13); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer63, 184); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 1, resource: sampler7}, {binding: 70, resource: {buffer: buffer99, size: 262}}], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup1, new Uint32Array(641), 75, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer17, 'uint16', 6, 11); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(3, buffer17, 4, 40); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer17, 'uint16', 32, 84); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(1, buffer55); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| } catch {} |
| let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| let buffer101 = device0.createBuffer({ |
| label: '\u{1f7c9}\u{1fcce}', |
| size: 136, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer62); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(7, buffer62, 16); |
| } catch {} |
| let arrayBuffer8 = buffer48.getMappedRange(56, 0); |
| try { |
| await promise12; |
| } catch {} |
| let autogeneratedBindGroupLayout10 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let textureView103 = texture23.createView({}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup16, new Uint32Array(2044), 453, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(36); |
| } catch {} |
| try { |
| commandEncoder88.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer55, 4); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(1, buffer92, 0, 30); |
| } catch {} |
| let buffer102 = device0.createBuffer({ |
| size: 84, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let textureView104 = texture13.createView({format: 'bgra8unorm', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder8.setVertexBuffer(4, buffer62, 4, 6); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 20, y: 20, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(1_146_817).fill(35), /* required buffer size: 1_146_817 */ |
| {offset: 209, bytesPerRow: 308, rowsPerImage: 169}, {width: 58, height: 5, depthOrArrayLayers: 23}); |
| } catch {} |
| let textureView105 = texture84.createView({}); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup16, []); |
| } catch {} |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder112.copyTextureToTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 0, y: 7, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder32.resolveQuerySet(querySet2, 119, 1, buffer46, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup24, new Uint32Array(298), 74, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer98, 'uint32', 16, 315); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer96, 40, 2); |
| } catch {} |
| document.body.prepend(canvas1); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 82, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 436, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let bindGroup35 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 37, resource: {buffer: buffer59, offset: 0}}, {binding: 82, resource: {buffer: buffer68}}], |
| }); |
| let buffer103 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC}); |
| let textureView106 = texture95.createView({aspect: 'all'}); |
| let sampler20 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| lodMinClamp: 24.56, |
| compare: 'always', |
| }); |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| buffer103.unmap(); |
| } catch {} |
| let pipeline15 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| try { |
| await promise14; |
| } catch {} |
| let device1 = await adapter1.requestDevice({ |
| defaultQueue: {}, |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'float32-blendable', |
| 'float16-renderable', |
| 'float32-renderable', |
| 'core-features-and-limits', |
| ], |
| requiredLimits: { |
| maxStorageBufferBindingSize: 248789522, |
| maxStorageTexturesPerShaderStage: 4, |
| maxTextureArrayLayers: 256, |
| maxUniformBufferBindingSize: 28001587, |
| maxVertexBuffers: 8, |
| }, |
| }); |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'film', transfer: 'gamma22curve'} }); |
| let buffer104 = device0.createBuffer({ |
| size: 196, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let texture115 = device0.createTexture({ |
| size: [120, 120, 49], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView107 = texture82.createView({mipLevelCount: 1}); |
| try { |
| device0.queue.writeBuffer(buffer50, 4, new DataView(new ArrayBuffer(76112)), 5795, 0); |
| } catch {} |
| let imageData20 = new ImageData(64, 20); |
| let texture116 = device0.createTexture({ |
| label: '\u00fe\uf43b\u0f53\u060b\u0a28', |
| size: [128], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer12, 'uint16', 0, 8); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(3, buffer62, 0, 9); |
| } catch {} |
| try { |
| commandEncoder102.resolveQuerySet(querySet2, 11, 10, buffer74, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u115b'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer101, 8, new DataView(new ArrayBuffer(3834)), 308, 0); |
| } catch {} |
| let bindGroup36 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout7, |
| entries: [{binding: 144, resource: {buffer: buffer70}}, {binding: 436, resource: externalTexture8}], |
| }); |
| let texture117 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup6, new Uint32Array(999), 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer102, 'uint16', 6, 9); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder78.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 456 */ |
| offset: 456, |
| bytesPerRow: 47872, |
| rowsPerImage: 356, |
| buffer: buffer75, |
| }, { |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 10, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup37 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout7, |
| entries: [{binding: 144, resource: {buffer: buffer74}}, {binding: 436, resource: externalTexture7}], |
| }); |
| try { |
| renderPassEncoder6.beginOcclusionQuery(20); |
| } catch {} |
| try { |
| renderBundleEncoder6.insertDebugMarker('\uce71'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer55, 0, new Uint32Array(8856).map((_, i) => i * 1), 43, 0); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(113); }; |
| } catch {} |
| document.body.append(img0); |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 3, resource: externalTexture2}, |
| {binding: 436, resource: externalTexture1}, |
| {binding: 0, resource: textureView0}, |
| {binding: 37, resource: {buffer: buffer59}}, |
| {binding: 82, resource: {buffer: buffer79}}, |
| {binding: 144, resource: {buffer: buffer74}}, |
| {binding: 1, resource: textureView4}, |
| ], |
| }); |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup12, new Uint32Array(1057), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup13, new Uint32Array(426), 37, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup8, new Uint32Array(861), 31, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(7, buffer73, 24, 23); |
| } catch {} |
| try { |
| commandEncoder75.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 36 */ |
| offset: 36, |
| buffer: buffer67, |
| }, { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer98, 'uint16', 230, 63); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer64, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup31, new Uint32Array(192), 71, 0); |
| } catch {} |
| document.body.prepend(img0); |
| offscreenCanvas1.height = 2495; |
| let buffer105 = device1.createBuffer({size: 472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let texture118 = device1.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 20}, |
| format: 'eac-rg11unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView108 = texture118.createView({dimension: '2d', baseArrayLayer: 1}); |
| let renderBundleEncoder23 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', depthReadOnly: true}); |
| try { |
| await promise15; |
| } catch {} |
| let texture119 = device0.createTexture({ |
| size: [128, 128, 26], |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture120 = device0.createTexture({ |
| size: [160, 120, 661], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let texture121 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView109 = texture59.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3}); |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer75, 'uint32', 80, 58); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'film', transfer: 'pq'} }); |
| let commandEncoder120 = device1.createCommandEncoder({}); |
| let texture122 = device1.createTexture({ |
| size: [300, 40, 26], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'astc-10x8-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture123 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let externalTexture13 = device1.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'}); |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup39 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 70, resource: {buffer: buffer70}}]}); |
| let texture124 = device0.createTexture({ |
| size: [20, 15, 1], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer69, 'uint32', 20, 8); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer69, 'uint32', 0, 4); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let textureView110 = texture118.createView({dimension: 'cube', baseArrayLayer: 2}); |
| let textureView111 = texture123.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| device1.queue.writeBuffer(buffer105, 200, new Float32Array(2613).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.418)), 539, 12); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(207, 288); |
| let texture125 = device0.createTexture({ |
| size: [60, 60, 1], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView112 = texture1.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup5, new Uint32Array(221), 29, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer89, 'uint16', 248, 44); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 0, new Float32Array(6613).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.301)), 545, 24); |
| } catch {} |
| let pipeline16 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| await gc(); |
| let commandEncoder121 = device1.createCommandEncoder({}); |
| let textureView113 = texture118.createView({label: '\ue92a\u{1f941}\u0b11', dimension: 'cube', aspect: 'all', baseArrayLayer: 1}); |
| try { |
| offscreenCanvas3.getContext('webgpu'); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: textureView80}]}); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let texture126 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup19, new Uint32Array(1615), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer58); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline5); |
| } catch {} |
| let commandEncoder123 = device1.createCommandEncoder({}); |
| let computePassEncoder26 = commandEncoder123.beginComputePass(); |
| try { |
| device1.queue.writeBuffer(buffer105, 12, new Uint32Array(6992).map((_, i) => i * 9), 1699, 24); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let pipelineLayout5 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout14]}); |
| let buffer106 = device1.createBuffer({size: 52, usage: GPUBufferUsage.UNIFORM}); |
| let imageData21 = new ImageData(132, 120); |
| let buffer107 = device0.createBuffer({size: 132, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let textureView114 = texture124.createView({}); |
| let textureView115 = texture87.createView({}); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.43, |
| maxAnisotropy: 13, |
| }); |
| try { |
| commandEncoder90.insertDebugMarker('\u0169'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData17, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 1, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder27 = commandEncoder121.beginComputePass(); |
| let promise16 = device1.queue.onSubmittedWorkDone(); |
| let commandEncoder124 = device0.createCommandEncoder(); |
| let textureView116 = texture119.createView({arrayLayerCount: 1}); |
| let texture127 = device0.createTexture({ |
| size: {width: 160}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer47, 'uint16', 4, 42); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let pipelineLayout6 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout14, veryExplicitBindGroupLayout14]}); |
| let buffer108 = device1.createBuffer({size: 4, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let computePassEncoder28 = commandEncoder120.beginComputePass(); |
| let sampler22 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 77.59}); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer70}}, |
| {binding: 436, resource: externalTexture2}, |
| {binding: 37, resource: {buffer: buffer88}}, |
| ], |
| }); |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let texture128 = device0.createTexture({ |
| size: [60, 60, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer104); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, buffer75, 0, 51); |
| } catch {} |
| try { |
| await shaderModule3.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer59, 32, new Uint32Array(1614).map((_, i) => i * 7), 502, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout15 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 44, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer109 = device1.createBuffer({size: 52, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture129 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 108}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| device1.pushErrorScope('internal'); |
| } catch {} |
| try { |
| renderBundleEncoder23.insertDebugMarker('\u2dea'); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer105, 116, new BigInt64Array(63046).map((_, i) => BigInt(i - 0)), 8861, 12); |
| } catch {} |
| let promise17 = device1.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 37, resource: {buffer: buffer79}}]}); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup12, new Uint32Array(1776), 215, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer47, 'uint32', 28, 15); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline0); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| let textureView117 = texture104.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer58, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout16 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer110 = device1.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let texture130 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 39}, |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| buffer106.unmap(); |
| } catch {} |
| let textureView118 = texture86.createView({}); |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer12, 'uint16', 20, 6); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(1, buffer73, 0); |
| } catch {} |
| try { |
| commandEncoder122.resolveQuerySet(querySet2, 71, 0, buffer48, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 8, new Uint32Array(35958).map((_, i) => i * 4), 5990, 0); |
| } catch {} |
| let shaderModule5 = device1.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| struct T7 { |
| f0: array<u32>, |
| } |
| |
| struct T8 { |
| f0: array<u32>, |
| } |
| |
| struct VertexInput18 { |
| @builtin(instance_index) instance_index: u32, |
| @location(4) location_4: vec2i, |
| @location(11) @interpolate(flat) location_11: vec2u, |
| @location(6) location_6: vec2f, |
| @location(15) location_15: vec4i, |
| @location(7) location_7: vec4f, |
| } |
| |
| /* used global variables: tex12 */ |
| fn fn0(a0: array<vec2h, 1>) -> vec2f { |
| var out: vec2f; |
| out = vec2f((vec4i(unconst_i32(289858706), unconst_i32(307408952), unconst_i32(-489909684), unconst_i32(18296049)) - unconst_i32(103888462)).aa); |
| if bool(a0[0][0]) { |
| out += vec2f(f32(a0[unconst_u32(1587373505)][unconst_u32(2615215829)])); |
| } |
| let vf61: vec3h = fract(vec3h(unconst_f16(6642.7), unconst_f16(578.7), unconst_f16(7290.2))); |
| var vf62: vec3u = max(vec3u(unconst_u32(349778817), unconst_u32(868780995), unconst_u32(111315187)), vec3u(unconst_u32(400091667), unconst_u32(11433906), unconst_u32(1987046130))); |
| vf62 += textureDimensions(tex12, unconst_i32(101315642)).rgr; |
| var vf63: vec2h = fma(vec2h(unconst_f16(4305.4), unconst_f16(-28622.9)), vec2h(unconst_f16(2895.9), unconst_f16(26659.8)), vec2h(unconst_f16(15182.3), unconst_f16(9852.5))); |
| var vf64: vec4i = (vec4i(unconst_i32(399790447), unconst_i32(367017143), unconst_i32(363037711), unconst_i32(-398351061)) - unconst_i32(907093763)); |
| return out; |
| _ = tex12; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T5 { |
| @align(16) f0: array<array<array<array<array<atomic<i32>, 1>, 1>, 1>, 1>>, |
| } |
| |
| struct T11 { |
| f0: T6, |
| } |
| |
| struct VertexInput19 { |
| @location(12) @interpolate(flat, first) location_12: u32, |
| @location(13) location_13: vec4u, |
| @location(8) location_8: vec2f, |
| } |
| |
| struct T2 { |
| @size(16) f0: atomic<i32>, |
| } |
| |
| struct T14 { |
| @size(30) f0: T9, |
| } |
| |
| struct FragmentOutput5 { |
| @location(0) location_0: vec4i, |
| } |
| |
| struct VertexInput22 { |
| @location(9) @interpolate(flat, first) location_9: i32, |
| } |
| |
| struct T1 { |
| f0: array<T0>, |
| } |
| |
| struct T9 { |
| f0: T4, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer111: array<array<array<array<array<array<array<f16, 5>, 1>, 3>, 1>, 1>, 1>>; |
| |
| struct T6 { |
| @align(16) f0: array<array<array<T0, 1>, 1>, 1>, |
| } |
| |
| struct T12 { |
| @size(224) f0: atomic<i32>, |
| @size(512) f1: vec4u, |
| @size(80) f2: T11, |
| } |
| |
| /* used global variables: buffer111, tex12 */ |
| @must_use |
| fn fn1() -> array<vec2i, 1> { |
| var out: array<vec2i, 1>; |
| let ptr70: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(643924664)][0][0][2][0]; |
| let vf65: vec4i = firstLeadingBit(vec4i(unconst_i32(682571127), unconst_i32(393209740), unconst_i32(106090254), unconst_i32(4383847))); |
| let ptr71: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][0][0][2][unconst_u32(15859411)]; |
| out[u32(buffer111[arrayLength(&buffer111)][0][0][0][2][u32((*&buffer111)[unconst_u32(1039356146)][0][unconst_u32(323408289)][u32(buffer111[unconst_u32(63690972)][0][unconst_u32(3081497611)][unconst_u32(1740465393)][unconst_u32(1425150364)][unconst_u32(2114995716)][unconst_u32(1078259474)])][2][0][unconst_u32(646813264)])][unconst_u32(341317359)])] = vec2i(i32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(1943521287)][0][unconst_u32(89857005)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(1271488946)][unconst_u32(562457008)][u32((*&buffer111)[arrayLength(&(*&buffer111))][0][0][unconst_u32(410878851)][unconst_u32(153557544)][unconst_u32(27942796)][4])][2][unconst_u32(389756695)][4])][0][unconst_u32(2588479233)])); |
| let ptr72: ptr<storage, array<array<array<f16, 5>, 1>, 3>, read_write> = &buffer111[unconst_u32(1085810)][unconst_u32(739077512)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(30984428)][unconst_u32(960097958)][unconst_u32(201522194)][unconst_u32(564654120)][0][unconst_u32(471396599)])][unconst_u32(193368784)]; |
| fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(405827118)][unconst_u32(938597793)][0][0][unconst_u32(220015577)][unconst_u32(62099186)][4]))); |
| let ptr73: ptr<storage, f16, read_write> = &buffer111[arrayLength(&buffer111)][u32((*&buffer111)[unconst_u32(1310583091)][0][unconst_u32(1562437151)][unconst_u32(451190856)][2][0][4])][unconst_u32(792481166)][unconst_u32(967486374)][unconst_u32(331700465)][unconst_u32(2154848740)][4]; |
| let ptr74: ptr<storage, array<f16, 5>, read_write> = &buffer111[arrayLength(&buffer111)][unconst_u32(606494818)][0][0][2][unconst_u32(874790891)]; |
| loop { |
| var vf66 = fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(557737620)][0][0][0][2][unconst_u32(81580988)][4]))); |
| let ptr75: ptr<storage, array<array<f16, 5>, 1>, read_write> = &(*&buffer111)[unconst_u32(457665734)][0][0][0][2]; |
| out[unconst_u32(1403944086)] = vec2i(i32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(921500466)][unconst_u32(829211125)][unconst_u32(501615644)][unconst_u32(1046812162)][unconst_u32(61595907)][4])); |
| var vf67 = fn0(array<vec2h, 1>(vec2h((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(58764675)][0][0][u32(buffer111[arrayLength(&buffer111)][0][unconst_u32(433788846)][0][2][0][4])][0][unconst_u32(28561152)]))); |
| out[unconst_u32(75752975)] *= vec2i(i32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(17019303)][0][0][u32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(31283698)][0][0][2][unconst_u32(346094354)][unconst_u32(302795276)])][0][4])); |
| out[unconst_u32(92785855)] = vec2i(i32(buffer111[arrayLength(&buffer111)][0][0][unconst_u32(647604630)][2][0][4])); |
| break; |
| _ = buffer111; |
| _ = tex12; |
| } |
| return out; |
| _ = tex12; |
| _ = buffer111; |
| } |
| |
| struct VertexInput21 { |
| @location(3) location_3: u32, |
| @location(2) @interpolate(flat, sample) location_2: vec2u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexInput20 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct T10 { |
| f0: array<atomic<i32>>, |
| } |
| |
| struct T4 { |
| @align(16) @size(16) f0: vec2h, |
| } |
| |
| struct T3 { |
| @size(512) f0: i32, |
| @size(320) f1: vec2f, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T13 { |
| f0: T9, |
| f1: array<array<atomic<i32>, 1>>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput23 { |
| @location(14) location_14: vec2u, |
| } |
| |
| @group(0) @binding(4) var tex12: texture_cube<f32>; |
| |
| struct T0 { |
| f0: vec4<bool>, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex4(@location(10) location_10: vec4u, @location(5) @interpolate(flat, centroid) location_5: vec4u, a2: VertexInput18, a3: VertexInput19, @location(0) @interpolate(linear, either) location_0: f16, a5: VertexInput20, @location(1) @interpolate(flat) location_1: vec2u, a7: VertexInput21, a8: VertexInput22, a9: VertexInput23) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out *= vec4f(f32(a5.vertex_index)); |
| while bool(location_10[unconst_u32(70099125)]) { |
| out = (bitcast<f32>(pack4x8snorm(vec4f(unconst_f32(0.09215), unconst_f32(0.4044), unconst_f32(0.07711), unconst_f32(0.1160e38)))) / vec2f(unconst_f32(0.1348), unconst_f32(0.1484))).yyxx; |
| out *= unpack4x8unorm(pack4xI8(vec4i(unconst_i32(113236913), unconst_i32(274219760), unconst_i32(1108743471), unconst_i32(185819856)))); |
| out = vec4f(f32(a8.location_9)); |
| out *= bitcast<vec4f>(a2.location_15); |
| break; |
| } |
| if bool(a9.location_14.g) { |
| out = vec4f(a2.location_4.yyxx.zxxz.gbba); |
| let vf68: u32 = a7.location_3; |
| var vf69: i32 = a2.location_4[unconst_u32(1127737024)]; |
| } |
| out += vec4f(bitcast<f32>(a5.vertex_index)); |
| let vf70: vec4h = exp2(vec4h(unconst_f16(4883.3), unconst_f16(-2867.1), unconst_f16(880.2), unconst_f16(19607.2))); |
| let vf71: VertexInput20 = a5; |
| out *= vec4f(a2.location_11.rgrr.yyzx.bbba.xyzw.aaag); |
| for (var it4=bitcast<u32>(reverseBits(unconst_i32(504309695))); it4<(a9.location_14[1] & 0xfff); it4++) { |
| out = bitcast<vec4f>(a3.location_13.grab.wywx.bbag); |
| var vf72: f32 = a2.location_7[unconst_u32(170012059)]; |
| loop { |
| let vf73: vec3h = reflect(vec3h(unconst_f16(21196.2), unconst_f16(15010.0), unconst_f16(8422.3)), vec3h(unconst_f16(741.6), unconst_f16(26229.8), unconst_f16(3226.9))); |
| out = unpack4x8unorm(dot(vec2u(select(vec2f(unconst_f32(0.2477e24), unconst_f32(0.01440)), vec2f(unconst_f32(0.8016), unconst_f32(0.08875e36)), vec2<bool>(unconst_bool(false), unconst_bool(true))).xy), vec2u(unconst_u32(460233627), unconst_u32(153681592)))); |
| out = vec4f(a2.location_11.yyyy); |
| out = vec4f(f32(a8.location_9)); |
| break; |
| } |
| out *= vec4f(f32(pack4x8unorm(vec4f(unconst_f32(0.09238e-15), unconst_f32(0.3470e29), unconst_f32(-0.4654e27), unconst_f32(0.2288e5))))); |
| out = unpack4x8unorm(location_5[unconst_u32(1123475529)]); |
| } |
| out = vec4f(a2.location_11.yyxy.aara.yzxz.aggg.rgar); |
| out = atan2(vec4f(unconst_f32(-0.5375), unconst_f32(0.00307e-14), unconst_f32(-0.08257e-15), unconst_f32(0.3993e22)), bitcast<vec4f>(a2.location_4.grgr.xwzx)); |
| return out; |
| } |
| |
| /* used global variables: buffer111, tex12 */ |
| @fragment |
| fn fragment6(@builtin(position) position: vec4f, @builtin(sample_index) sample_index: u32, @builtin(front_facing) front_facing: bool) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| while bool(buffer111[unconst_u32(907431799)][0][0][0][unconst_u32(1247149388)][0][unconst_u32(266410952)]) { |
| out.location_0 -= vec4i(i32(buffer111[unconst_u32(7709429)][0][unconst_u32(597540797)][0][2][0][4])); |
| let ptr76: ptr<storage, array<array<f16, 5>, 1>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][unconst_u32(464758587)][unconst_u32(210350216)][2]; |
| let ptr77: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(438000279)][unconst_u32(59910098)][0][unconst_u32(892743085)][unconst_u32(127763019)]; |
| out.location_0 -= vec4i(i32((*&buffer111)[unconst_u32(60067418)][0][0][0][2][unconst_u32(253268163)][4])); |
| break; |
| _ = buffer111; |
| } |
| out.location_0 = vec4i(i32((*&buffer111)[unconst_u32(158085395)][unconst_u32(1439194488)][0][unconst_u32(21416865)][2][0][4])); |
| var vf74 = fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(1374089743)][unconst_u32(1784623139)][0][0][2][0][4]))); |
| let ptr78: ptr<storage, array<array<f16, 5>, 1>, read_write> = &buffer111[unconst_u32(131529928)][0][unconst_u32(270996292)][unconst_u32(543779834)][2]; |
| vf74 = vec2f(f32((*&buffer111)[unconst_u32(3660481357)][unconst_u32(1859310776)][u32(buffer111[arrayLength(&buffer111)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(879577475)][0][0][2][0][4])][unconst_u32(428736758)][unconst_u32(682614546)][unconst_u32(49280466)][0][unconst_u32(746473576)])][unconst_u32(687549388)][2][0][4])); |
| loop { |
| for (var jj17=0u; jj17<3; jj17++) { buffer111[unconst_u32(1378383016)][unconst_u32(349795350)][jj17][unconst_u32(1383696797)][unconst_u32(1096619974)][u32(buffer111[arrayLength(&buffer111)][0][0][unconst_u32(19193634)][unconst_u32(827395663)][0][bitcast<u32>(position[unconst_u32(141712775)])])][unconst_u32(263588639)] = (*&buffer111)[arrayLength(&(*&buffer111))][0][unconst_u32(85785480)][0][2][0][unconst_u32(42197490)]; } |
| _ = fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_u32(1220902597)][0][unconst_u32(556878183)][unconst_u32(131649493)][u32(buffer111[arrayLength(&buffer111)][0][0][0][2][0][4])][unconst_u32(2012817572)][4]))); |
| let ptr79: ptr<storage, f16, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][0][0][2][0][4]; |
| for (var it6=u32(buffer111[unconst_u32(1303876945)][u32(buffer111[unconst_u32(1654662470)][unconst_u32(1106498075)][0][unconst_u32(327828301)][2][u32((*&buffer111)[unconst_u32(744231970)][unconst_u32(579885222)][unconst_u32(1383472216)][0][unconst_u32(792527395)][unconst_u32(109612167)][unconst_u32(710629584)])][4])][unconst_u32(677446380)][0][2][0][4]); it6<(textureDimensions(tex12, i32(pack4xI8(vec4i(i32((*&buffer111)[arrayLength(&(*&buffer111)) - 1][0][0][0][2][0][4])))))[0] & 0xfff); it6++) { |
| fn0(array<vec2h, 1>(vec2h((*&buffer111)[unconst_i32(261567886)][0][0][0][2][0][4]))); |
| out.location_0 &= vec4i(i32((*&buffer111)[unconst_u32(2372121395)][unconst_u32(165747988)][unconst_u32(132810931)][unconst_u32(712119666)][unconst_u32(1475908790)][0][4])); |
| let ptr80: ptr<storage, f16, read_write> = &(*&buffer111)[unconst_u32(46731547)][0][0][0][2][0][unconst_u32(505681395)]; |
| for (var it5=u32((*&buffer111)[unconst_u32(811423483)][0][0][unconst_u32(142029526)][2][unconst_u32(3457307)][4]); it5<(u32(buffer111[arrayLength(&buffer111)][unconst_u32(750363586)][unconst_u32(180267308)][0][unconst_u32(2188301839)][0][4]) & 0xfff); it5++) { |
| let ptr81: ptr<storage, f16, read_write> = &buffer111[arrayLength(&buffer111)][0][u32((*&buffer111)[unconst_u32(2374767596)][unconst_u32(913301243)][0][unconst_u32(1521182977)][2][unconst_u32(87665970)][4])][0][2][0][4]; |
| buffer111[unconst_u32(887641115)][unconst_u32(1363983629)][u32(buffer111[arrayLength(&buffer111)][unconst_u32(307859812)][0][unconst_u32(1287056532)][unconst_u32(514222944)][0][4])][unconst_u32(1198295125)][unconst_u32(716002818)][u32(buffer111[unconst_u32(86432740)][unconst_u32(918854974)][0][unconst_u32(645342376)][2][unconst_u32(418372328)][u32((*&buffer111)[u32(buffer111[arrayLength(&buffer111)][u32((*&buffer111)[arrayLength(&(*&buffer111))][unconst_u32(40780699)][unconst_u32(202555959)][0][2][0][4])][0][0][unconst_u32(592286634)][0][4])][unconst_u32(1646422398)][0][0][u32(buffer111[unconst_u32(194949726)][0][0][unconst_u32(210674350)][unconst_u32(28114972)][0][4])][0][unconst_u32(1270059922)])])][unconst_u32(515258050)] = buffer111[arrayLength(&buffer111)][0][0][0][unconst_u32(531388967)][0][unconst_u32(498219599)]; |
| let ptr82: ptr<storage, array<f16, 5>, read_write> = &buffer111[arrayLength(&buffer111)][0][0][unconst_u32(279124641)][2][unconst_u32(648844626)]; |
| _ = buffer111; |
| } |
| _ = tex12; |
| _ = buffer111; |
| } |
| let ptr83: ptr<storage, array<f16, 5>, read_write> = &(*&buffer111)[arrayLength(&(*&buffer111))][0][0][unconst_u32(380679243)][unconst_u32(186537328)][0]; |
| break; |
| _ = buffer111; |
| _ = tex12; |
| } |
| buffer111[unconst_u32(210704401)][unconst_u32(215565526)][unconst_u32(579746955)][unconst_u32(409001149)][unconst_u32(94539270)][unconst_u32(248039869)][4] += (*&buffer111)[unconst_u32(65834513)][0][0][0][unconst_u32(709475732)][unconst_u32(1331977708)][4]; |
| return out; |
| _ = buffer111; |
| _ = tex12; |
| } |
| |
| /* used global variables: tex12 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute5(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u) { |
| var vf75: mat2x3f = (mat2x3f(unconst_f32(0.1377), unconst_f32(0.01324e16), unconst_f32(0.2363), unconst_f32(0.03664), unconst_f32(0.00042), unconst_f32(0.08610e-31)) - mat2x3f()); |
| fn0(array<vec2h, 1>(vec2h(unpack2x16float(unconst_u32(1900260079))))); |
| vf75 += mat2x3f(bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), f32(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), bitcast<f32>(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)]), f32(global_invocation_id[u32((vec3i(unconst_i32(160783173), unconst_i32(331296862), unconst_i32(203590564)) / unconst_i32(-231840057)).b)])); |
| fn0(array<vec2h, 1>(vec2h(vf75[unconst_i32(0)].zy))); |
| vf75 = mat2x3f(bitcast<vec3f>(textureDimensions(tex12, unconst_i32(87124486)).yxx), vec3f(textureDimensions(tex12, unconst_i32(87124486)).grr.yxz)); |
| _ = tex12; |
| }`, |
| }); |
| let commandEncoder126 = device1.createCommandEncoder({}); |
| let sampler23 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 87.51, |
| compare: 'less-equal', |
| maxAnisotropy: 19, |
| }); |
| let computePassEncoder29 = commandEncoder126.beginComputePass(); |
| let renderBundleEncoder24 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8'}); |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await promise18; |
| } catch {} |
| let texture131 = device1.createTexture({ |
| size: {width: 75, height: 10, depthOrArrayLayers: 88}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture132 = device1.createTexture({ |
| size: {width: 150, height: 20, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder25 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', sampleCount: 1}); |
| let pipeline17 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}}); |
| try { |
| adapter0.label = '\u7d3b\uc3ef\u{1fedb}'; |
| } catch {} |
| let bindGroup43 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer109}}, |
| {binding: 4, resource: textureView113}, |
| {binding: 44, resource: {buffer: buffer106}}, |
| ], |
| }); |
| let commandEncoder127 = device1.createCommandEncoder({}); |
| let textureView119 = texture131.createView({dimension: '2d', baseArrayLayer: 8}); |
| let texture133 = device1.createTexture({ |
| size: [75, 10, 1], |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture134 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundleEncoder26 = device1.createRenderBundleEncoder({ |
| colorFormats: ['rgba32sint'], |
| depthStencilFormat: 'stencil8', |
| sampleCount: 1, |
| depthReadOnly: false, |
| stencilReadOnly: true, |
| }); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteRp431', transfer: 'bt2020_12bit'} }); |
| let pipelineLayout7 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout16, veryExplicitBindGroupLayout16]}); |
| let commandEncoder128 = device1.createCommandEncoder({}); |
| let textureView120 = texture131.createView({dimension: '2d', format: 'rgba16float', baseArrayLayer: 1}); |
| try { |
| computePassEncoder28.setBindGroup(2, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup43, [0]); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| buffer108.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer105, 24, new Float16Array(14043).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.970)), 551, 36); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte170m', transfer: 'gamma28curve'} }); |
| let textureView121 = texture111.createView({format: 'rgba16float'}); |
| let textureView122 = texture103.createView({baseArrayLayer: 0}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer15, 'uint32', 48, 18); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 0, y: 12 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 16, y: 3, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer113 = device1.createBuffer({size: 168, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder129 = device1.createCommandEncoder({}); |
| let querySet3 = device1.createQuerySet({type: 'occlusion', count: 246}); |
| let texture135 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 7}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder30 = commandEncoder127.beginComputePass(); |
| try { |
| computePassEncoder28.setPipeline(pipeline17); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| override override11 = false; |
| |
| @group(0) @binding(177) var<uniform> buffer115: array<array<vec4f, 38>, 1>; |
| |
| @group(1) @binding(383) var<storage, read_write> buffer121: array<array<i32, 38>>; |
| |
| struct VertexInput30 { |
| @location(12) @interpolate(flat, sample) location_12: i32, |
| } |
| |
| override override10: i32 = 128454244; |
| |
| var<workgroup> vw8: array<vec2f, 1>; |
| |
| @group(1) @binding(351) var<uniform> buffer120: array<array<array<VertexInput27, 4>, 5>, 5>; |
| |
| struct VertexInput33 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct FragmentInput13 { |
| @location(0) @interpolate(flat, sample) location_0: vec2u, |
| } |
| |
| @group(0) @binding(197) var<storage, read_write> buffer116: array<array<array<array<FragmentInput10, 13>, 4>, 6>>; |
| |
| override override12: bool; |
| |
| struct VertexInput29 { |
| @location(3) location_3: u32, |
| } |
| |
| struct VertexInput31 { |
| @location(4) location_4: i32, |
| @location(10) @interpolate(flat, first) location_10: vec4u, |
| } |
| |
| struct VertexInput28 { |
| @location(11) @interpolate(perspective, either) location_11: f32, |
| @location(6) @interpolate(flat, either) location_6: f16, |
| } |
| |
| struct VertexInput27 { |
| @location(14) @interpolate(perspective, centroid) location_14: vec4f, |
| } |
| |
| struct FragmentInput12 { |
| @location(6) location_6: vec4f, |
| } |
| |
| struct FragmentInput8 { |
| @location(7) location_7: f32, |
| @location(10) @interpolate(flat, first) location_10: vec2u, |
| @location(11) @interpolate(flat, sample) location_11: vec4i, |
| @location(14) @interpolate(perspective, either) location_14: f32, |
| } |
| |
| struct T0 { |
| @size(200) f0: i32, |
| f1: vec2i, |
| @size(88) f2: array<array<array<vec4i, 1>, 5>, 1>, |
| } |
| |
| @group(2) @binding(0) var<storage, read_write> buffer122: array<array<array<array<VertexInput31, 16>, 1>, 7>>; |
| |
| @group(1) @binding(4) var<storage, read_write> buffer119: array<FragmentInput8>; |
| |
| struct VertexInput34 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct VertexInput26 { |
| @location(2) @interpolate(flat) location_2: vec2i, |
| @location(8) @interpolate(linear) location_8: f32, |
| } |
| |
| struct FragmentInput11 { |
| @location(13) location_13: vec2f, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentInput15 { |
| @builtin(position) position: vec4f, |
| } |
| |
| struct VertexInput32 { |
| @location(0) @interpolate(flat) location_0: vec2i, |
| } |
| |
| @id(60121) override override13: i32 = 94900840; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw10: array<atomic<i32>, 1>; |
| |
| struct FragmentInput10 { |
| @location(1) location_1: f16, |
| } |
| |
| struct VertexInput25 { |
| @location(13) @interpolate(flat) location_13: vec2i, |
| } |
| |
| var<workgroup> vw9: array<atomic<i32>, 1>; |
| |
| struct FragmentOutput6 { |
| @location(6) location_6: f32, |
| @location(5) @interpolate(flat, centroid) location_5: vec2i, |
| @location(0) @interpolate(flat, first) location_0: vec2u, |
| } |
| |
| struct VertexOutput4 { |
| @location(5) @interpolate(flat, either) location_5: u32, |
| @location(3) location_3: u32, |
| @location(12) location_12: vec2h, |
| @location(1) location_1: vec2i, |
| @location(7) @interpolate(flat) location_7: vec4i, |
| @location(8) @interpolate(flat, first) location_8: vec4u, |
| @location(2) location_2: vec2h, |
| @builtin(position) position: vec4f, |
| @location(11) @interpolate(flat, either) location_11: vec4h, |
| @location(14) location_14: vec4f, |
| @location(15) @interpolate(flat, sample) location_15: vec4i, |
| @location(13) @interpolate(flat, centroid) location_13: vec2u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct FragmentInput14 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| struct VertexInput24 { |
| @location(1) location_1: vec4f, |
| @location(9) @interpolate(linear) location_9: vec2h, |
| @location(5) location_5: vec4u, |
| } |
| |
| @group(0) @binding(329) var st4: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentInput9 { |
| @location(8) location_8: vec4f, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex5(@location(7) @interpolate(flat) location_7: vec4i, a1: VertexInput24, @location(15) @interpolate(perspective, first) location_15: vec4h, a3: VertexInput25, a4: VertexInput26, a5: VertexInput27, a6: VertexInput28, a7: VertexInput29, a8: VertexInput30, a9: VertexInput31, a10: VertexInput32, a11: VertexInput33, a12: VertexInput34) -> VertexOutput4 { |
| var out: VertexOutput4; |
| var vf76: f32 = out.position[unconst_u32(1968284550)]; |
| let vf77: bool = override12; |
| out.location_8 &= unpack4xU8(u32(a8.location_12)); |
| return out; |
| _ = override12; |
| } |
| |
| /* used global variables: buffer115, buffer116, buffer119, buffer120, buffer121, buffer122, st4 */ |
| @fragment |
| fn fragment7(@location(9) location_9: vec4h, a1: FragmentInput8, @location(2) @interpolate(perspective, centroid) location_2: vec4f, a3: FragmentInput9, a4: FragmentInput10, a5: FragmentInput11, a6: FragmentInput12, a7: FragmentInput13, a8: FragmentInput14, a9: FragmentInput15) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| let ptr84: ptr<storage, VertexInput31, read_write> = &(*&buffer122)[arrayLength(&(*&buffer122))][6][unconst_u32(492999490)][unconst_u32(363742571)]; |
| for (var jj98=0u; jj98<40; jj98++) { buffer121[unconst_u32(187136589)][jj98] = i32(buffer116[pack4xU8Clamp(bitcast<vec4u>((*&buffer115)[unconst_u32(603020452)][37].gbga.rgaa))][5][3][unconst_u32(1423473961)].location_1); } |
| let ptr85: ptr<uniform, array<array<VertexInput27, 4>, 5>> = &(*&buffer120)[4]; |
| let ptr86: ptr<storage, FragmentInput10, read_write> = &(*&buffer116)[arrayLength(&(*&buffer116))][unconst_u32(1061407859)][3][12]; |
| textureStore(st4, i32(buffer116[arrayLength(&buffer116)][unconst_u32(891994081)][3][12].location_1), vec4u(vec4u(unconst_u32(131413931), unconst_u32(2173767082), unconst_u32(217562214), unconst_u32(445102356)))); |
| buffer119[pack4x8unorm((*&buffer120)[4][unconst_u32(44322755)][3].location_14)].location_11 &= vec4i(bitcast<i32>((*&buffer115)[unconst_u32(349102726)][unconst_u32(232356674)][unconst_u32(775902460)])); |
| let ptr87: ptr<storage, FragmentInput10, read_write> = &(*&buffer116)[arrayLength(&(*&buffer116))][unconst_u32(168456577)][unconst_u32(1173280622)][unconst_u32(225219525)]; |
| buffer122[unconst_u32(967170119)][bitcast<u32>((*&buffer121)[arrayLength(&(*&buffer121)) - 1][37])][unconst_u32(726373236)][unconst_u32(263959244)].location_10 = unpack4xU8(bitcast<u32>(buffer121[unconst_u32(323214340)][unconst_u32(228041540)])); |
| buffer122[unconst_u32(1038716194)][unconst_u32(901652999)][unconst_u32(1471595058)][unconst_u32(1829447742)].location_4 -= i32(buffer115[0][unconst_u32(3593818318)][unconst_u32(582909744)]); |
| return out; |
| _ = buffer119; |
| _ = st4; |
| _ = buffer120; |
| _ = buffer116; |
| _ = buffer121; |
| _ = buffer115; |
| _ = buffer122; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute6(@builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) { |
| atomicMax(&vw9[unconst_u32(573240235)], unconst_i32(64684075)); |
| }`, |
| }); |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 285, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 401, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }}, |
| ], |
| }); |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 3, resource: externalTexture3}, |
| {binding: 144, resource: {buffer: buffer74, offset: 0}}, |
| {binding: 1, resource: textureView8}, |
| {binding: 0, resource: textureView0}, |
| {binding: 82, resource: {buffer: buffer68}}, |
| {binding: 37, resource: {buffer: buffer88, size: 124}}, |
| {binding: 436, resource: externalTexture1}, |
| ], |
| }); |
| let texture136 = device0.createTexture({size: [128, 128, 26], format: 'rg32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let textureView123 = texture93.createView({dimension: '3d', format: 'r32uint'}); |
| try { |
| renderBundleEncoder3.setVertexBuffer(2, buffer64); |
| } catch {} |
| await gc(); |
| let imageData22 = new ImageData(120, 4); |
| let veryExplicitBindGroupLayout18 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 51, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 99, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 317, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 445, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| let buffer124 = device1.createBuffer({ |
| size: 126, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView124 = texture123.createView({mipLevelCount: 1}); |
| let externalTexture14 = device1.importExternalTexture({source: videoFrame12}); |
| document.body.prepend(img0); |
| let textureView125 = texture53.createView({}); |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer53); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer60, 'uint16', 36, 0); |
| } catch {} |
| try { |
| commandEncoder101.copyTextureToTexture({ |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 0, y: 24, z: 5}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 3, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture137 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer105, 28, new Float32Array(21998).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9139)), 2088, 44); |
| } catch {} |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| let texture138 = device0.createTexture({size: {width: 128}, dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let textureView126 = texture68.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder19.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup16, new Uint32Array(87), 76, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer92); |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 1, resource: sampler0}, {binding: 70, resource: {buffer: buffer70}}], |
| }); |
| let textureView127 = texture112.createView({format: 'rgba16float', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup34, new Uint32Array(1049), 49, 0); |
| } catch {} |
| let pipeline18 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer58, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| commandEncoder130.copyBufferToBuffer(buffer90, 8, buffer24, 8, 8); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: textureView8}, |
| {binding: 0, resource: textureView3}, |
| {binding: 3, resource: externalTexture0}, |
| {binding: 436, resource: externalTexture9}, |
| {binding: 144, resource: {buffer: buffer73}}, |
| {binding: 37, resource: {buffer: buffer68}}, |
| {binding: 82, resource: {buffer: buffer88}}, |
| ], |
| }); |
| let texture139 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 49}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView128 = texture8.createView({aspect: 'all'}); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup25, new Uint32Array(4398), 75, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(0, buffer45, 8, 20); |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device1.createBindGroupLayout({ |
| label: '\u{1f9ad}\u{1fe49}\ufbec\uffed\u0d5d', |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 51, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 99, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 317, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 445, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(84); }; |
| } catch {} |
| document.body.prepend(img0); |
| let buffer125 = device1.createBuffer({label: '\u9188\u7a8f', size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder132 = device1.createCommandEncoder({}); |
| let texture140 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 163}, |
| mipLevelCount: 4, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(4, buffer110, 8, 21); |
| } catch {} |
| let imageData23 = new ImageData(132, 56); |
| try { |
| renderBundleEncoder26.insertDebugMarker('\ub2a0'); |
| } catch {} |
| let buffer126 = device0.createBuffer({ |
| label: '\u1a86\u{1ff38}\u{1ff6a}\u{1fca7}\u0ace\ufb50\u{1fafc}', |
| size: 220, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup26); |
| } catch {} |
| let buffer127 = device1.createBuffer({ |
| size: 51, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| try { |
| computePassEncoder29.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup43, new Uint32Array(111), 26, 1); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(1, buffer105, 92); |
| } catch {} |
| let pipeline19 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5', constants: {}}}); |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(119); }; |
| } catch {} |
| let commandEncoder133 = device1.createCommandEncoder({}); |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup43, new Uint32Array(499), 12, 1); |
| } catch {} |
| try { |
| await shaderModule5.getCompilationInfo(); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer125, 0, new Uint32Array(2174).map((_, i) => i * 1), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup46, new Uint32Array(2558), 326, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer15, 'uint16', 6, 19); |
| } catch {} |
| try { |
| commandEncoder45.copyBufferToBuffer(buffer90, 40, buffer64, 4, 0); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let buffer128 = device0.createBuffer({size: 322, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let commandEncoder134 = device0.createCommandEncoder(); |
| let computePassEncoder31 = commandEncoder48.beginComputePass(); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'}); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer12, 'uint32', 12, 24); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder4.insertDebugMarker('\u71c2'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 12, y: 30 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| textureView21.label = '\u{1faa4}\u{1ff91}\u0af5\u{1fe65}\u762a\ueb2d\u06e5\u2293\u3a02\u97e3'; |
| } catch {} |
| let textureView129 = texture23.createView({}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup41, new Uint32Array(233), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(6, buffer73); |
| } catch {} |
| try { |
| computePassEncoder23.insertDebugMarker('\ub78f'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 15, y: 3, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise19; |
| } catch {} |
| document.body.prepend(canvas1); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame10}); |
| try { |
| computePassEncoder31.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline7); |
| } catch {} |
| let buffer129 = device1.createBuffer({size: 396, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| let texture141 = device1.createTexture({ |
| size: {width: 37, height: 5, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder27 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8'}); |
| try { |
| computePassEncoder30.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup43, [0]); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer53, 0, 17); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup18); |
| } catch {} |
| let buffer130 = device1.createBuffer({ |
| size: 468, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder136 = device1.createCommandEncoder({}); |
| let texture142 = device1.createTexture({ |
| size: {width: 150, height: 20, depthOrArrayLayers: 25}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView130 = texture133.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture123, |
| mipLevel: 2, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(74).fill(207), /* required buffer size: 74 */ |
| {offset: 74}, {width: 75, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline20 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment6', |
| constants: {}, |
| targets: [{ |
| format: 'rgba32sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| stencilFront: {compare: 'less', failOp: 'keep', depthFailOp: 'increment-clamp', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'never', failOp: 'decrement-clamp', depthFailOp: 'replace'}, |
| stencilReadMask: 178624565, |
| stencilWriteMask: 97406249, |
| depthBias: -347398980, |
| depthBiasSlopeScale: 671.3284385317326, |
| depthBiasClamp: 0.0, |
| }, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 192, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x2', offset: 48, shaderLocation: 9}, |
| {format: 'uint32', offset: 0, shaderLocation: 1}, |
| {format: 'float16x2', offset: 24, shaderLocation: 7}, |
| {format: 'sint16x2', offset: 12, shaderLocation: 4}, |
| {format: 'float32x3', offset: 32, shaderLocation: 8}, |
| {format: 'snorm8x4', offset: 32, shaderLocation: 0}, |
| {format: 'snorm16x2', offset: 12, shaderLocation: 6}, |
| {format: 'uint16x4', offset: 28, shaderLocation: 2}, |
| {format: 'uint16x4', offset: 40, shaderLocation: 12}, |
| {format: 'sint16x4', offset: 40, shaderLocation: 15}, |
| {format: 'uint8x2', offset: 30, shaderLocation: 5}, |
| {format: 'uint16x4', offset: 36, shaderLocation: 10}, |
| {format: 'uint16x4', offset: 40, shaderLocation: 13}, |
| {format: 'uint32x4', offset: 88, shaderLocation: 11}, |
| {format: 'uint32x4', offset: 8, shaderLocation: 3}, |
| {format: 'uint8x2', offset: 20, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let buffer131 = device0.createBuffer({size: 24, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let textureView131 = texture126.createView({dimension: '2d-array'}); |
| let texture143 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 107}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView132 = texture128.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer17, 'uint32', 16, 6); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer49, 'uint16', 2, 9); |
| } catch {} |
| let pipeline21 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule6, constants: {}}}); |
| let gpuCanvasContext4 = canvas2.getContext('webgpu'); |
| let texture144 = device0.createTexture({ |
| size: [40], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer58, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(6, buffer64, 0); |
| } catch {} |
| try { |
| commandEncoder69.clearBuffer(buffer11); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup37, new Uint32Array(2446), 860, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer61, 'uint16', 0, 42); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| try { |
| commandEncoder110.copyTextureToBuffer({ |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 26, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2624 */ |
| offset: 2624, |
| buffer: buffer94, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: imageData14, |
| origin: { x: 6, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 7, y: 13, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer132 = device0.createBuffer({size: 76, usage: GPUBufferUsage.MAP_READ}); |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup38, new Uint32Array(734), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer79, 12, 128); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup24, new Uint32Array(4419), 151, 0); |
| } catch {} |
| try { |
| buffer96.unmap(); |
| } catch {} |
| let texture145 = gpuCanvasContext1.getCurrentTexture(); |
| let renderBundleEncoder28 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', stencilReadOnly: true}); |
| try { |
| renderBundleEncoder28.setBindGroup(3, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline20); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 44, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let renderBundleEncoder29 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', depthReadOnly: true}); |
| try { |
| computePassEncoder27.setPipeline(pipeline19); |
| } catch {} |
| let buffer133 = device1.createBuffer({size: 704, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder137 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(0, buffer110, 0, 10); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer125, 4, new Uint32Array(12597).map((_, i) => i * 10), 476, 0); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture141, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(45).fill(182), /* required buffer size: 45 */ |
| {offset: 45}, {width: 37, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise20 = device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule5, |
| constants: {}, |
| targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALPHA}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'greater', failOp: 'decrement-clamp', passOp: 'decrement-wrap'}, |
| stencilBack: {compare: 'greater', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'replace'}, |
| stencilReadMask: 218804187, |
| stencilWriteMask: 788463542, |
| depthBias: -1614511068, |
| depthBiasSlopeScale: 561.7592318266848, |
| }, |
| vertex: { |
| module: shaderModule5, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 0, shaderLocation: 11}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 13}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 15}, |
| {format: 'sint32', offset: 0, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 2}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint32', offset: 0, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6}, |
| {format: 'uint32', offset: 0, shaderLocation: 1}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 8}, |
| {format: 'float16x2', offset: 0, shaderLocation: 0}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'uint32x4', offset: 256, shaderLocation: 12}, |
| {format: 'float32x4', offset: 152, shaderLocation: 7}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', cullMode: 'front'}, |
| }); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let bindGroup47 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: [{binding: 0, resource: {buffer: buffer98}}]}); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer128, 'uint32', 40, 23); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(271).fill(223), /* required buffer size: 271 */ |
| {offset: 271, bytesPerRow: 22}, {width: 1, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte240m', transfer: 'iec61966-2-1'} }); |
| try { |
| renderPassEncoder15.setVertexBuffer(3, buffer131, 0, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(38); }; |
| } catch {} |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer62, 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u8a3f'); |
| } catch {} |
| let imageData24 = new ImageData(4, 4); |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'smpte170m'} }); |
| let autogeneratedBindGroupLayout11 = pipeline20.getBindGroupLayout(0); |
| let bindGroup48 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 4, resource: textureView110}, |
| {binding: 44, resource: {buffer: buffer133, size: 35}}, |
| {binding: 0, resource: {buffer: buffer109}}, |
| ], |
| }); |
| let commandEncoder140 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup43, new Uint32Array(1337), 364, 1); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder128.clearBuffer(buffer105); |
| } catch {} |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout1]}); |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let texture146 = device0.createTexture({size: [30], dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView133 = texture11.createView({}); |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup21, new Uint32Array(140), 33, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer53, 'uint16', 28, 18); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(4, buffer96); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 4, new BigInt64Array(625).map((_, i) => BigInt(i - 1)), 40, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup11, []); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(4, buffer50, 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup11, new Uint32Array(514), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToBuffer(buffer12, 4, buffer48, 4, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: offscreenCanvas3, |
| origin: { x: 58, y: 102 }, |
| flipY: true, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 91, y: 12, z: 7}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 17, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer134 = device1.createBuffer({size: 308, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup43, new Uint32Array(134), 24, 1); |
| } catch {} |
| try { |
| buffer110.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| let commandEncoder142 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(9); }; |
| } catch {} |
| try { |
| adapter1.label = '\u{1faf3}\u097f\u9dd8\u529f\u0389\u0232\u040c\u992b\u0252'; |
| } catch {} |
| let textureView134 = texture78.createView({dimension: 'cube', baseArrayLayer: 1}); |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup8, new Uint32Array(2471), 991, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device1.label = '\u08fc\u4fe9'; |
| } catch {} |
| let buffer135 = device1.createBuffer({size: 204, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let commandEncoder143 = device1.createCommandEncoder({}); |
| let textureView135 = texture132.createView({dimension: '2d-array', aspect: 'all'}); |
| try { |
| computePassEncoder27.setBindGroup(3, bindGroup43, new Uint32Array(506), 101, 1); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline20); |
| } catch {} |
| let pipeline22 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule5, |
| constants: {}, |
| targets: [{format: 'rgba32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'increment-wrap', passOp: 'zero'}, |
| stencilBack: {compare: 'less-equal', failOp: 'increment-wrap', depthFailOp: 'invert', passOp: 'increment-wrap'}, |
| stencilReadMask: 459443339, |
| stencilWriteMask: 73027427, |
| depthBias: -2143524602, |
| depthBiasSlopeScale: 828.8452979953711, |
| depthBiasClamp: 850.1795103923619, |
| }, |
| vertex: { |
| module: shaderModule5, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 32, |
| attributes: [ |
| {format: 'unorm8x2', offset: 2, shaderLocation: 0}, |
| {format: 'uint32', offset: 0, shaderLocation: 1}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 11}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 96, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x2', offset: 8, shaderLocation: 6}, |
| {format: 'uint16x2', offset: 16, shaderLocation: 14}, |
| {format: 'sint32', offset: 4, shaderLocation: 9}, |
| {format: 'uint32', offset: 0, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 8, shaderLocation: 13}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 4}, |
| {format: 'uint32x4', offset: 28, shaderLocation: 5}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 7}, |
| {format: 'sint32x3', offset: 68, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 12, shaderLocation: 8}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32x2', offset: 104, shaderLocation: 3}, |
| {format: 'uint32x4', offset: 436, shaderLocation: 2}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let imageData25 = new ImageData(48, 4); |
| let textureView136 = texture102.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup45, new Uint32Array(329), 108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup12, new Uint32Array(1954), 668, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(2, buffer17, 36, 55); |
| } catch {} |
| document.body.append(canvas2); |
| let textureView137 = texture101.createView({}); |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup12, new Uint32Array(957), 89, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer61, 'uint32', 0, 18); |
| } catch {} |
| let commandEncoder144 = device1.createCommandEncoder({}); |
| let textureView138 = texture131.createView({dimension: '2d', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 1}); |
| document.body.prepend(canvas0); |
| let pipelineLayout9 = device0.createPipelineLayout({ |
| bindGroupLayouts: [autogeneratedBindGroupLayout10, veryExplicitBindGroupLayout8, veryExplicitBindGroupLayout10, autogeneratedBindGroupLayout9], |
| }); |
| let buffer136 = device0.createBuffer({size: 612, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let textureView139 = texture83.createView({aspect: 'all'}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup35, new Uint32Array(4314), 243, 0); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| let sampler24 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 89.31, |
| }); |
| try { |
| device1.queue.writeBuffer(buffer127, 4, new DataView(new ArrayBuffer(75080)), 4517, 0); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(5, buffer58, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer59, 4, new Float32Array(2735).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.01215)), 628, 8); |
| } catch {} |
| let buffer137 = device0.createBuffer({size: 308, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView140 = texture81.createView({baseArrayLayer: 0}); |
| let sampler25 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 78.99}); |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup45, new Uint32Array(3909), 387, 0); |
| } catch {} |
| let textureView141 = texture133.createView({mipLevelCount: 1}); |
| let externalTexture17 = device1.importExternalTexture({source: videoFrame8, colorSpace: 'srgb'}); |
| let commandEncoder146 = device0.createCommandEncoder({label: '\u09b5\u{1fff7}\u{1fc44}\uc6c4\u0f89\u05a1\uadef'}); |
| let textureView142 = texture69.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder22.beginOcclusionQuery(110); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer53, 'uint32', 4, 0); |
| } catch {} |
| document.body.prepend(canvas1); |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup22, [0]); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup0, new Uint32Array(309), 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer137, 8, new DataView(new Uint8Array(2411).map((_, i) => i).buffer), 430, 84); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture75, |
| mipLevel: 0, |
| origin: {x: 1, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(44_080).fill(59), /* required buffer size: 44_080 */ |
| {offset: 82, bytesPerRow: 241, rowsPerImage: 87}, {width: 17, height: 9, depthOrArrayLayers: 3}); |
| } catch {} |
| let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4}}); |
| let veryExplicitBindGroupLayout22 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer138 = device1.createBuffer({size: 336, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE, mappedAtCreation: false}); |
| let texture147 = device1.createTexture({ |
| size: [37, 5, 66], |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder32 = commandEncoder136.beginComputePass(); |
| let renderBundleEncoder30 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', depthReadOnly: true}); |
| try { |
| computePassEncoder32.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder24.setPipeline(pipeline22); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer124, 32, new Float32Array(1650).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.473)), 369, 4); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let commandEncoder147 = device1.createCommandEncoder({}); |
| let textureView143 = texture133.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup43, [0]); |
| } catch {} |
| try { |
| commandEncoder144.insertDebugMarker('\u{1f9c8}'); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(62); }; |
| } catch {} |
| document.body.prepend(img0); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup19, new Uint32Array(665), 190, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(1, buffer62, 8, 12); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let buffer139 = device1.createBuffer({size: 628, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder148 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup43, new Uint32Array(331), 185, 1); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder24.insertDebugMarker('\u0314'); |
| } catch {} |
| let promise22 = device1.queue.onSubmittedWorkDone(); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup9, new Uint32Array(1532), 483, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup5, new Uint32Array(647), 11, 0); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToBuffer(buffer75, 100, buffer70, 68, 40); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 8, new Uint16Array(1612).map((_, i) => i + 4), 361, 16); |
| } catch {} |
| document.body.append(img0); |
| let commandEncoder149 = device1.createCommandEncoder({}); |
| let texture148 = device1.createTexture({ |
| size: [75, 10, 3], |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let texture149 = gpuCanvasContext2.getCurrentTexture(); |
| let renderBundleEncoder31 = device1.createRenderBundleEncoder({ |
| colorFormats: ['rgba32sint'], |
| depthStencilFormat: 'stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer130, 'uint16', 70, 99); |
| } catch {} |
| try { |
| renderBundleEncoder24.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder23.insertDebugMarker('\u026e'); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 1, resource: externalTexture16}, |
| {binding: 64, resource: textureView17}, |
| {binding: 4, resource: textureView14}, |
| {binding: 630, resource: textureView16}, |
| {binding: 0, resource: {buffer: buffer52, offset: 0}}, |
| ], |
| }); |
| let commandEncoder150 = device0.createCommandEncoder({}); |
| let textureView144 = texture27.createView({label: '\u091f\u0498'}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer60, 'uint16', 8, 4); |
| } catch {} |
| let pipeline24 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, targets: [{format: 'rg32uint'}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 56, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x2', offset: 0, shaderLocation: 7}, |
| {format: 'float32', offset: 12, shaderLocation: 12}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 6}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x2', offset: 6, shaderLocation: 5}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 8}, |
| {format: 'float32', offset: 0, shaderLocation: 0}, |
| {format: 'sint8x2', offset: 4, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 2}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'uint16x2', offset: 12, shaderLocation: 1}, |
| {format: 'sint16x2', offset: 4, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 4}, |
| {format: 'snorm16x4', offset: 4, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 1, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 64, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 630, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let buffer140 = device0.createBuffer({size: 56, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let textureView145 = texture11.createView({dimension: '2d-array'}); |
| try { |
| commandEncoder71.copyTextureToBuffer({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2560 */ |
| offset: 2560, |
| rowsPerImage: 1523, |
| buffer: buffer94, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder116.pushDebugGroup('\u00e9'); |
| } catch {} |
| await gc(); |
| let buffer141 = device0.createBuffer({ |
| size: 319, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup47, []); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer92); |
| } catch {} |
| try { |
| commandEncoder116.popDebugGroup(); |
| } catch {} |
| try { |
| commandEncoder39.insertDebugMarker('\u{1f998}'); |
| } catch {} |
| try { |
| await promise22; |
| } catch {} |
| let imageData26 = new ImageData(28, 188); |
| try { |
| computePassEncoder24.setBindGroup(3, bindGroup21, new Uint32Array(42), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup14, new Uint32Array(3315), 932, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer17, 0); |
| } catch {} |
| try { |
| commandEncoder35.copyBufferToBuffer(buffer75, 160, buffer69, 28, 28); |
| } catch {} |
| let textureView146 = texture124.createView({}); |
| let texture150 = device0.createTexture({ |
| size: [160, 120, 661], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder5.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer137, 'uint32', 16, 34); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer55); |
| } catch {} |
| try { |
| renderBundleEncoder13.insertDebugMarker('\u32a6'); |
| } catch {} |
| let pipeline25 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex1', |
| buffers: [ |
| { |
| arrayStride: 32, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 13}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 4}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 14}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 1}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 9}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 2}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 11}, |
| {format: 'float32x3', offset: 0, shaderLocation: 6}, |
| {format: 'sint8x2', offset: 4, shaderLocation: 8}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 0}, |
| {format: 'snorm8x2', offset: 2, shaderLocation: 10}, |
| ], |
| }, |
| {arrayStride: 20, attributes: [{format: 'float32x2', offset: 0, shaderLocation: 12}]}, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true}, |
| }); |
| document.body.prepend(img0); |
| let commandEncoder151 = device0.createCommandEncoder({label: '\u0765\ueed0\u{1fcd0}'}); |
| let textureView147 = texture11.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer75, 'uint16', 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(2, buffer48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer75, 'uint32', 60, 97); |
| } catch {} |
| try { |
| commandEncoder111.resolveQuerySet(querySet0, 20, 0, buffer96, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder152 = device1.createCommandEncoder(); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup48, new Uint32Array(165), 2, 1); |
| } catch {} |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'gamma22curve'} }); |
| let buffer142 = device0.createBuffer({size: 264, usage: GPUBufferUsage.COPY_DST}); |
| let texture151 = device0.createTexture({ |
| size: {width: 40}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(3, bindGroup37, []); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture87, |
| mipLevel: 0, |
| origin: {x: 1, y: 3, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(83).fill(99), /* required buffer size: 83 */ |
| {offset: 83, bytesPerRow: 56}, {width: 3, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder153 = device1.createCommandEncoder({}); |
| let textureView148 = texture140.createView({aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 12, arrayLayerCount: 1}); |
| try { |
| buffer138.unmap(); |
| } catch {} |
| document.body.prepend(img0); |
| let textureView149 = texture119.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer49, 'uint16', 70, 1); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer62, 0, 2); |
| } catch {} |
| try { |
| commandEncoder118.insertDebugMarker('\u042b'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer59, 12, new Uint32Array(1171).map((_, i) => i * 1), 76, 4); |
| } catch {} |
| let renderPassEncoder23 = commandEncoder75.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView49, |
| depthSlice: 56, |
| clearValue: { r: 205.0, g: -498.8, b: -310.2, a: 259.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler26 = device0.createSampler({addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 91.53, maxAnisotropy: 1}); |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer126, 'uint32', 28, 56); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline5); |
| } catch {} |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup16, new Uint32Array(2313), 820, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder135.copyBufferToBuffer(buffer67, 28, buffer102, 16, 8); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let texture152 = device0.createTexture({ |
| size: [30, 30, 48], |
| mipLevelCount: 2, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer89, 'uint16', 16, 95); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline24); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer97, 12, new Uint32Array(4933).map((_, i) => i * 6), 81, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline26 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4}}); |
| await gc(); |
| let buffer143 = device0.createBuffer({size: 164, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer24, 'uint16', 2, 6); |
| } catch {} |
| try { |
| buffer74.unmap(); |
| } catch {} |
| try { |
| commandEncoder73.insertDebugMarker('\u14ef'); |
| } catch {} |
| let renderBundleEncoder32 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8'}); |
| try { |
| renderBundleEncoder30.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(1, buffer105, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer135, 4, new DataView(new Uint8Array(24406).map((_, i) => i).buffer), 9548, 48); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture141, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(9).fill(97), /* required buffer size: 9 */ |
| {offset: 9}, {width: 37, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout12 = pipeline19.getBindGroupLayout(0); |
| let bindGroup50 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 51, resource: {buffer: buffer138, size: 260}}, |
| {binding: 317, resource: externalTexture13}, |
| {binding: 41, resource: {buffer: buffer139}}, |
| {binding: 445, resource: sampler23}, |
| {binding: 4, resource: textureView120}, |
| {binding: 99, resource: {buffer: buffer124, size: 92}}, |
| ], |
| }); |
| let texture153 = device1.createTexture({ |
| size: {width: 37, height: 5, depthOrArrayLayers: 67}, |
| mipLevelCount: 3, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder33 = device1.createRenderBundleEncoder({colorFormats: ['rgba32sint'], depthStencilFormat: 'stencil8', stencilReadOnly: true}); |
| let externalTexture18 = device1.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup50); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(2, buffer105, 0, 4); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer130, 80, new Uint32Array(3696).map((_, i) => i * 6), 235, 0); |
| } catch {} |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup20, new Uint32Array(1234), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer126, 'uint32', 0, 11); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer64); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer144 = device0.createBuffer({size: 32, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| let texture154 = device0.createTexture({ |
| size: [20, 15, 82], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView150 = texture13.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder10.setVertexBuffer(3, buffer17, 56, 267); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup24, new Uint32Array(1998), 73, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(7, buffer92); |
| } catch {} |
| try { |
| commandEncoder50.copyTextureToBuffer({ |
| texture: texture116, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 320 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2680 */ |
| offset: 2680, |
| bytesPerRow: 48640, |
| buffer: buffer94, |
| }, {width: 40, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder73.resolveQuerySet(querySet2, 86, 4, buffer74, 0); |
| } catch {} |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup43, [0]); |
| } catch {} |
| await gc(); |
| let bindGroup51 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 41, resource: {buffer: buffer139}}, |
| {binding: 317, resource: externalTexture18}, |
| {binding: 99, resource: {buffer: buffer113, offset: 0}}, |
| {binding: 4, resource: textureView138}, |
| {binding: 445, resource: sampler23}, |
| {binding: 51, resource: {buffer: buffer138}}, |
| ], |
| }); |
| let texture155 = device1.createTexture({ |
| size: {width: 75, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView151 = texture118.createView({dimension: 'cube'}); |
| let renderBundleEncoder34 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout13 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder159 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup15, new Uint32Array(2045), 53, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(7, 13, 0, 11); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer72, 'uint16', 26, 1); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(5, buffer63, 0, 173); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToBuffer({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 26, y: 7, z: 6}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2904 */ |
| offset: 2904, |
| bytesPerRow: 22016, |
| buffer: buffer94, |
| }, {width: 7, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let img1 = await imageWithData(66, 21, '#10101010', '#20202020'); |
| let textureView152 = texture141.createView({dimension: '2d-array', aspect: 'stencil-only'}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup43, new Uint32Array(804), 52, 1); |
| } catch {} |
| try { |
| commandEncoder153.resolveQuerySet(querySet3, 108, 7, buffer130, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer127, 16, new DataView(new ArrayBuffer(10856)), 337, 0); |
| } catch {} |
| let textureView153 = texture133.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder33 = commandEncoder148.beginComputePass(); |
| try { |
| computePassEncoder33.setPipeline(pipeline19); |
| } catch {} |
| try { |
| buffer124.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout24 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 44, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture156 = device1.createTexture({ |
| size: {width: 37, height: 5, depthOrArrayLayers: 82}, |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder33.setBindGroup(2, bindGroup48, new Uint32Array(1580), 95, 1); |
| } catch {} |
| try { |
| renderBundleEncoder34.setVertexBuffer(0, buffer105, 0, 159); |
| } catch {} |
| let texture157 = device1.createTexture({ |
| size: [300, 40, 659], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer130, 'uint16', 86, 38); |
| } catch {} |
| try { |
| device1.pushErrorScope('internal'); |
| } catch {} |
| let imageData27 = new ImageData(32, 52); |
| let texture158 = device1.createTexture({ |
| size: {width: 75, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView154 = texture142.createView({aspect: 'stencil-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 3}); |
| let computePassEncoder34 = commandEncoder129.beginComputePass(); |
| try { |
| computePassEncoder34.setPipeline(pipeline17); |
| } catch {} |
| let promise23 = device1.queue.onSubmittedWorkDone(); |
| let buffer145 = device1.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let textureView155 = texture153.createView({aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 12}); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup50, new Uint32Array(32), 5, 0); |
| } catch {} |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let texture159 = device0.createTexture({ |
| size: {width: 128, height: 128, depthOrArrayLayers: 658}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup13, new Uint32Array(2837), 25, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer12, 'uint16', 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(7, buffer104, 0, 10); |
| } catch {} |
| let bindGroup52 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer124, size: 52}}, |
| {binding: 4, resource: textureView113}, |
| {binding: 44, resource: {buffer: buffer106}}, |
| ], |
| }); |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer130, 'uint16', 26, 15); |
| } catch {} |
| try { |
| buffer130.unmap(); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| struct VertexInput35 { |
| @location(12) location_12: vec2f, |
| @location(2) location_2: vec2u, |
| @location(3) @interpolate(flat) location_3: vec2h, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer146: array<array<array<array<T1, 7>, 1>, 64>>; |
| |
| struct T2 { |
| @size(36) f0: array<T1, 2>, |
| f1: array<T1, 3>, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp6: i32 = i32(263456924); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @id(28617) override override14: i32; |
| |
| struct VertexOutput5 { |
| @builtin(position) position: vec4f, |
| @location(5) @interpolate(perspective, first) location_5: vec2f, |
| } |
| |
| struct T1 { |
| f0: vec2f, |
| } |
| |
| struct T4 { |
| @size(16) f0: atomic<i32>, |
| @align(16) f1: array<T1>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T5 { |
| @size(8) f0: array<atomic<u32>, 1>, |
| } |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| struct T0 { |
| @align(8) @size(8) f0: f16, |
| } |
| |
| struct VertexInput36 { |
| @location(1) location_1: vec2i, |
| } |
| |
| var<private> vp5: vec4<bool> = vec4<bool>(false, true, false, false); |
| |
| @group(0) @binding(10) var<storage, read_write> buffer147: T0; |
| |
| @group(0) @binding(115) var st6: texture_storage_2d<r32float, read_write>; |
| |
| struct ComputeInput8 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex6(@location(7) @interpolate(linear) location_7: vec2h, @builtin(vertex_index) vertex_index: u32, a2: VertexInput35, @location(4) @interpolate(linear) location_4: vec4f, a4: VertexInput36, @location(0) location_0: vec4i) -> VertexOutput5 { |
| var out: VertexOutput5; |
| loop { |
| var vf78: bool = all(vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true))); |
| var vf79: vec4<bool> = (bitcast<vec4h>(a2.location_2) == vec4h(log2(unconst_f16(3253.2)))); |
| let vf80: u32 = dot4U8Packed(bitcast<u32>((vec2i(unconst_i32(798764159), unconst_i32(239592757)) & vec2i(unconst_i32(135915264), unconst_i32(149124152))).g), unconst_u32(77937894)); |
| let vf81: vec4<bool> = (vec4h(unconst_f16(-879.2), unconst_f16(31179.5), unconst_f16(6961.1), unconst_f16(4345.9)) == vec4h(unconst_f16(4118.4), unconst_f16(6116.3), unconst_f16(17325.9), unconst_f16(2040.2))); |
| break; |
| } |
| out.position = out.location_5.grrg; |
| out.position *= out.location_5.rrgg; |
| out.position *= vec4f(out.location_5[unconst_u32(517983907)]); |
| return out; |
| } |
| |
| /* used global variables: buffer146, st6 */ |
| @fragment |
| fn fragment8(@location(5) @interpolate(linear, first) location_5: vec2f, @builtin(sample_mask) sample_mask: u32, @builtin(position) position: vec4f, @builtin(sample_index) sample_index: u32) -> @location(200) vec2f { |
| var out: vec2f; |
| while bool((*&buffer146)[arrayLength(&(*&buffer146))][63][0][6].f0[0]) { |
| buffer146[unconst_u32(637364316)][63][unconst_u32(2293829127)][unconst_u32(230366298)].f0 -= (*&buffer146)[unconst_u32(1328064750)][unconst_u32(817389686)][bitcast<u32>(buffer146[unconst_u32(90806945)][unconst_u32(603661139)][0][6].f0.g)][6].f0; |
| let ptr88: ptr<storage, array<array<array<T1, 7>, 1>, 64>, read_write> = &(*&buffer146)[arrayLength(&(*&buffer146)) - 1]; |
| _ = buffer146; |
| } |
| let ptr89: ptr<storage, T1, read_write> = &(*&buffer146)[unconst_u32(939510935)][unconst_u32(488071858)][0][unconst_u32(873509716)]; |
| let ptr90: ptr<storage, T1, read_write> = &(*&buffer146)[arrayLength(&(*&buffer146))][unconst_u32(8757383)][unconst_u32(456906809)][6]; |
| let ptr91: ptr<storage, array<array<array<T1, 7>, 1>, 64>, read_write> = &buffer146[arrayLength(&buffer146)]; |
| let ptr92: ptr<storage, array<array<T1, 7>, 1>, read_write> = &(*&buffer146)[arrayLength(&(*&buffer146))][bitcast<u32>((*&buffer146)[unconst_i32(-153511085)][63][0][6].f0.y)]; |
| for (var jj11=0u; jj11<66; jj11++) { buffer146[unconst_u32(33271488)][jj11][unconst_u32(251677959)][6].f0 = vec2f((*ptr91)[unconst_u32(982435446)][0][6].f0[unconst_u32(729126752)]); } |
| switch i32(buffer146[unconst_u32(830269011)][63][unconst_u32(1693924736)][6].f0[1]) { |
| case 136228209, default, 154381337 { |
| let ptr93: ptr<storage, vec2f, read_write> = &buffer146[arrayLength(&buffer146)][63][unconst_u32(553817573)][unconst_u32(488349136)].f0; |
| textureStore(st6, vec2i(unconst_i32(186890820), unconst_i32(53048225)), vec4f((*&buffer146)[arrayLength(&(*&buffer146))][63][0][6].f0.rggg)); |
| var vf82: f32 = position[pack2x16float((*&buffer146)[unconst_u32(729637878)][63][0][6].f0)]; |
| let vf83: ptr<storage, array<array<array<array<T1, 7>, 1>, 64>>, read_write> = &buffer146; |
| break; |
| _ = st6; |
| _ = buffer146; |
| } |
| } |
| out = buffer146[arrayLength(&buffer146)][63][unconst_u32(289738343)][6].f0; |
| let ptr94: ptr<storage, T1, read_write> = &(*&buffer146)[unconst_u32(774810208)][unconst_u32(188442068)][0][6]; |
| return out; |
| _ = st6; |
| _ = buffer146; |
| } |
| |
| /* used global variables: buffer146, buffer147 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute7(a0: ComputeInput8) { |
| while bool(buffer146[arrayLength(&buffer146)][63][unconst_u32(361598832)][6].f0[unconst_u32(65775927)]) { |
| let vf84: f32 = buffer146[arrayLength(&buffer146)][63][0][6].f0[unconst_u32(38442265)]; |
| buffer147.f0 = f16(buffer146[unconst_u32(576884345)][unconst_u32(33176916)][unconst_u32(74772985)][6].f0[0]); |
| _ = buffer146; |
| _ = buffer147; |
| } |
| let ptr95: ptr<storage, T1, read_write> = &buffer146[arrayLength(&buffer146)][unconst_u32(271165464)][0][unconst_u32(703695502)]; |
| _ = buffer146; |
| _ = buffer147; |
| }`, |
| }); |
| let buffer148 = device0.createBuffer({size: 148, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let textureView156 = texture106.createView({dimension: '2d-array'}); |
| try { |
| commandEncoder57.copyBufferToBuffer(buffer103, 32, buffer48, 8, 4); |
| } catch {} |
| try { |
| computePassEncoder19.insertDebugMarker('\u2f1f'); |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 70, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer149 = device0.createBuffer({label: '\u07ba\u{1fdea}\u{1ff84}\uf1c9\u0d85\u8ef9', size: 48, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder20.setVertexBuffer(3, buffer75, 216, 13); |
| } catch {} |
| try { |
| buffer99.unmap(); |
| } catch {} |
| try { |
| commandEncoder78.copyTextureToTexture({ |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 4, y: 2, z: 11}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 0, new Float16Array(7006).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.036)), 891, 0); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise24; |
| } catch {} |
| await gc(); |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpteSt4281', transfer: 'bt709'} }); |
| let bindGroup53 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 82, resource: {buffer: buffer0}}, |
| {binding: 436, resource: externalTexture1}, |
| {binding: 3, resource: externalTexture2}, |
| {binding: 37, resource: {buffer: buffer88, size: 132}}, |
| {binding: 0, resource: textureView3}, |
| {binding: 1, resource: textureView1}, |
| {binding: 144, resource: {buffer: buffer70}}, |
| ], |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer75, 'uint32', 4, 35); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(0, buffer64, 0, 3); |
| } catch {} |
| try { |
| commandEncoder56.resolveQuerySet(querySet1, 5, 1, buffer96, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer93, 44, new Float32Array(4330).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.159)), 946, 0); |
| } catch {} |
| let sampler27 = device1.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.45, |
| compare: 'less', |
| }); |
| let texture160 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| dimension: '2d', |
| format: 'stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView157 = texture135.createView({dimension: '2d', format: 'stencil8', baseArrayLayer: 1}); |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} }); |
| let bindGroup54 = device1.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 0, resource: {buffer: buffer124, size: 64}}, {binding: 4, resource: textureView113}], |
| }); |
| let commandEncoder162 = device1.createCommandEncoder({}); |
| let texture161 = device1.createTexture({ |
| size: {width: 150, height: 20, depthOrArrayLayers: 329}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'bt709'} }); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup18, new Uint32Array(2514), 30, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer14, 'uint32', 0, 9); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let shaderModule8 = device1.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| struct T2 { |
| @align(64) f0: array<array<f16, 1>>, |
| } |
| |
| var<private> vp7: f16 = f16(29812.9); |
| |
| struct FragmentInput17 { |
| @location(10) @interpolate(flat, centroid) location_10: i32, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer150: array<array<array<array<array<f16, 1>, 3>, 1>, 5>>; |
| |
| struct VertexInput40 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexInput38 { |
| @location(14) location_14: vec2i, |
| @location(3) @interpolate(perspective, either) location_3: vec2f, |
| @location(1) location_1: i32, |
| } |
| |
| struct FragmentInput16 { |
| @location(15) @interpolate(perspective, centroid) location_15: vec4h, |
| @location(0) @interpolate(perspective, first) location_0: vec4h, |
| } |
| |
| struct VertexInput37 { |
| @location(9) @interpolate(perspective, either) location_9: vec4f, |
| @location(12) @interpolate(flat, sample) location_12: vec2i, |
| @location(15) location_15: vec2i, |
| @location(0) location_0: f16, |
| @location(11) @interpolate(flat) location_11: f32, |
| @location(13) @interpolate(perspective, sample) location_13: f16, |
| @location(7) @interpolate(flat, sample) location_7: vec4f, |
| } |
| |
| @id(44468) override override16: bool; |
| |
| struct FragmentOutput7 { |
| @location(0) @interpolate(linear, sample) location_0: vec4f, |
| } |
| |
| struct VertexOutput6 { |
| @location(0) @interpolate(perspective, first) location_0: vec4h, |
| @location(3) location_3: vec2f, |
| @location(5) location_5: i32, |
| @location(12) @interpolate(flat, either) location_12: vec2f, |
| @invariant @builtin(position) position: vec4f, |
| @location(10) @interpolate(flat, centroid) location_10: i32, |
| @location(1) @interpolate(flat, centroid) location_1: vec4i, |
| @location(11) @interpolate(linear, either) location_11: f16, |
| @location(15) @interpolate(perspective, centroid) location_15: vec4h, |
| @location(14) @interpolate(flat, either) location_14: u32, |
| } |
| |
| var<private> vp8: array<vec4<bool>, 15> = array<vec4<bool>, 15>(vec4<bool>(false, false, false, false), vec4<bool>(true, true, false, false), vec4<bool>(false, false, true, false), vec4<bool>(true, true, false, true), vec4<bool>(true, true, true, false), vec4<bool>(false, true, false, false), vec4<bool>(true, false, false, false), vec4<bool>(false, true, false, true), vec4<bool>(true, false, false, true), vec4<bool>(true, false, true, true), vec4<bool>(true, true, true, true), vec4<bool>(true, false, false, false), vec4<bool>(true, false, false, false), vec4<bool>(false, false, false, true), vec4<bool>(true, false, false, false)); |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| override override17: i32; |
| |
| var<workgroup> vw11: atomic<u32>; |
| |
| @id(38409) override override15: u32; |
| |
| @group(0) @binding(44) var<uniform> buffer151: FragmentOutput7; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T1 { |
| @size(30) f0: atomic<u32>, |
| } |
| |
| struct T0 { |
| @size(30) f0: atomic<u32>, |
| } |
| |
| override override18: i32 = 157480045; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput39 { |
| @location(10) location_10: f16, |
| @location(5) location_5: vec4u, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex7(@location(2) @interpolate(linear) location_2: f16, @location(6) @interpolate(flat, center) location_6: vec2u, @location(4) location_4: i32, a3: VertexInput37, a4: VertexInput38, a5: VertexInput39, @location(8) @interpolate(perspective, center) location_8: vec4f, a7: VertexInput40, @builtin(vertex_index) vertex_index: u32) -> VertexOutput6 { |
| var out: VertexOutput6; |
| out.location_12 -= vec2f(f32(location_4)); |
| out.location_1 *= vec4i(dot(vec4i(unconst_i32(69143797), unconst_i32(497704541), unconst_i32(6454276), unconst_i32(725583302)), vec4i(unconst_i32(-22361386), unconst_i32(212123021), unconst_i32(66532497), unconst_i32(502115614)))); |
| let vf85: vec4u = a5.location_5; |
| let vf86: vec2h = faceForward(vec2h(unconst_f16(873.3), unconst_f16(27823.5)), vec2h(unconst_f16(14027.4), unconst_f16(12580.0)), vec2h(unconst_f16(4826.4), unconst_f16(2445.1))); |
| let vf87: i32 = override18; |
| let ptr96: ptr<function, i32> = &out.location_5; |
| out.position = unpack4x8snorm(vf85[a5.location_5[2]]); |
| var vf88: i32 = a3.location_15[unconst_u32(956158459)]; |
| var vf89: VertexInput39 = a5; |
| switch vec4u(vp8[14]).b { |
| case default, 1388094151: { |
| let ptr97: ptr<function, i32> = &out.location_10; |
| let ptr98: ptr<function, i32> = &out.location_10; |
| } |
| } |
| let vf90: i32 = vf87; |
| out.position = vec4f(vp8[14].argr); |
| return out; |
| _ = override18; |
| } |
| |
| /* used global variables: buffer150, buffer151 */ |
| @fragment |
| fn fragment9(@location(1) @interpolate(flat) location_1: vec4i, a1: FragmentInput16, @location(12) @interpolate(linear) location_12: vec2f, a3: FragmentInput17, @location(5) location_5: i32, @location(3) @interpolate(linear, sample) location_3: vec2f, @location(11) @interpolate(linear) location_11: f16, @location(14) location_14: u32) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| let ptr99: ptr<storage, f16, read_write> = &(*&buffer150)[arrayLength(&(*&buffer150))][4][u32(out.location_0[unconst_u32(1015786147)])][2][unconst_u32(683341988)]; |
| let ptr100: ptr<storage, array<f16, 1>, read_write> = &buffer150[u32(buffer150[arrayLength(&buffer150)][unconst_u32(12143892)][0][2][0])][4][unconst_u32(387423006)][unconst_u32(255545862)]; |
| vp8[unconst_u32(563680923)] = vec4<bool>(bool((*&buffer150)[arrayLength(&(*&buffer150))][4][unconst_u32(127956160)][2][0])); |
| out.location_0 = vec4f(f32((*&buffer150)[unconst_u32(1555458754)][4][unconst_u32(7387297)][2][0])); |
| out.location_0 += vec4f(f32(buffer150[unconst_u32(437863326)][unconst_u32(1001854011)][unconst_u32(269997617)][unconst_u32(167599512)][0])); |
| var vf91: f32 = buffer151.location_0[unconst_u32(536695842)]; |
| let ptr101: ptr<storage, array<f16, 1>, read_write> = &(*&buffer150)[arrayLength(&(*&buffer150))][4][unconst_u32(644840059)][2]; |
| vf91 *= f32((*&buffer150)[unconst_u32(2202504583)][unconst_u32(420463729)][0][2][0]); |
| return out; |
| _ = buffer151; |
| _ = buffer150; |
| }`, |
| }); |
| let commandEncoder163 = device1.createCommandEncoder({}); |
| let textureView158 = texture118.createView({dimension: '2d', baseArrayLayer: 3}); |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup51); |
| } catch {} |
| try { |
| buffer138.unmap(); |
| } catch {} |
| let bindGroup55 = device1.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 4, resource: textureView151}, {binding: 0, resource: {buffer: buffer135}}], |
| }); |
| let commandEncoder164 = device1.createCommandEncoder({}); |
| let computePassEncoder35 = commandEncoder132.beginComputePass(); |
| try { |
| commandEncoder133.copyTextureToTexture({ |
| texture: texture156, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture130, |
| mipLevel: 1, |
| origin: {x: 39, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder165 = device0.createCommandEncoder(); |
| let texture162 = device0.createTexture({ |
| size: [20, 15, 82], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| buffer52.unmap(); |
| } catch {} |
| try { |
| commandEncoder50.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 568 */ |
| offset: 568, |
| bytesPerRow: 3072, |
| rowsPerImage: 196, |
| buffer: buffer136, |
| }, { |
| texture: texture124, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer101, 24, new DataView(new ArrayBuffer(25400)), 1452, 0); |
| } catch {} |
| let promise25 = device0.queue.onSubmittedWorkDone(); |
| try { |
| globalThis.someLabel = renderPassEncoder8.label; |
| } catch {} |
| let autogeneratedBindGroupLayout14 = pipeline25.getBindGroupLayout(1); |
| let buffer152 = device0.createBuffer({size: 540, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let textureView159 = texture162.createView({format: 'rg32sint', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(6, buffer45, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 8, new Float32Array(31879).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.707)), 608, 4); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let buffer153 = device0.createBuffer({size: 220, usage: GPUBufferUsage.COPY_DST}); |
| let texture163 = device0.createTexture({ |
| size: [60, 60, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder8.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(3, undefined, 0, 18_778_771); |
| } catch {} |
| try { |
| buffer149.unmap(); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 1, resource: sampler0}, {binding: 70, resource: {buffer: buffer70}}], |
| }); |
| let buffer154 = device0.createBuffer({size: 96, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let texture164 = device0.createTexture({ |
| size: {width: 40, height: 30, depthOrArrayLayers: 165}, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder18.beginOcclusionQuery(136); |
| } catch {} |
| try { |
| renderPassEncoder18.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline3); |
| } catch {} |
| try { |
| computePassEncoder0.insertDebugMarker('\u{1fb90}'); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder(); |
| let texture165 = device0.createTexture({ |
| size: [128, 128, 100], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture166 = device0.createTexture({ |
| size: {width: 128}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder24 = commandEncoder73.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView25, |
| depthSlice: 26, |
| clearValue: { r: -311.3, g: 656.1, b: 88.58, a: 801.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer12, 'uint32', 8, 41); |
| } catch {} |
| try { |
| commandEncoder86.copyBufferToBuffer(buffer102, 20, buffer141, 76, 0); |
| } catch {} |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let texture167 = device0.createTexture({ |
| size: {width: 30, height: 30, depthOrArrayLayers: 12}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture168 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1, depthReadOnly: true}); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup13, new Uint32Array(99), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup15, new Uint32Array(538), 70, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(6, buffer140); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer148, 12, new DataView(new ArrayBuffer(53740)), 2938, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let buffer155 = device1.createBuffer({size: 1009, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let textureView160 = texture140.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 23}); |
| try { |
| computePassEncoder35.setPipeline(pipeline19); |
| } catch {} |
| let imageData28 = new ImageData(4, 16); |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer145, 'uint32', 4, 3); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(7, buffer110, 0); |
| } catch {} |
| try { |
| buffer105.unmap(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let textureView161 = texture165.createView({}); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup29, new Uint32Array(3393), 657, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer57, 'uint16', 2, 21); |
| } catch {} |
| try { |
| buffer49.unmap(); |
| } catch {} |
| try { |
| commandEncoder141.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 240 */ |
| offset: 240, |
| bytesPerRow: 25856, |
| buffer: buffer136, |
| }, { |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer141, 16, new Uint32Array(55).map((_, i) => i * 1), 9, 0); |
| } catch {} |
| offscreenCanvas2.height = 1060; |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} }); |
| let texture169 = device0.createTexture({ |
| size: {width: 30, height: 30, depthOrArrayLayers: 4}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder19.setVertexBuffer(1, buffer92); |
| } catch {} |
| try { |
| buffer67.unmap(); |
| } catch {} |
| let textureView162 = texture133.createView({aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| commandEncoder128.copyTextureToTexture({ |
| texture: texture130, |
| mipLevel: 0, |
| origin: {x: 22, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture157, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 48}, |
| aspect: 'all', |
| }, |
| {width: 20, height: 2, depthOrArrayLayers: 8}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer138, 20, new DataView(new Uint8Array(10351).map((_, i) => i).buffer), 1231, 44); |
| } catch {} |
| let pipeline27 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5'}}); |
| let buffer156 = device0.createBuffer({size: 148, usage: GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let textureView163 = texture83.createView({}); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder14.beginOcclusionQuery(127); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer102, 'uint16', 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer89, 'uint32', 36, 16); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 12, y: 7, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(18).fill(168), /* required buffer size: 18 */ |
| {offset: 18, bytesPerRow: 73}, {width: 9, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer157 = device1.createBuffer({size: 80, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let sampler28 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 30.45, |
| compare: 'equal', |
| }); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup52, [0]); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer127, 8, new DataView(new ArrayBuffer(6904)), 141, 8); |
| } catch {} |
| let pipeline28 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5', constants: {}}}); |
| try { |
| await promise25; |
| } catch {} |
| let texture170 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer61, 'uint32', 0, 55); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup35, []); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer76, 'uint16', 4, 5); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 160, height: 120, depthOrArrayLayers: 661} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 10, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture150, |
| mipLevel: 0, |
| origin: {x: 0, y: 19, z: 109}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline29 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| let texture171 = device0.createTexture({ |
| size: {width: 60, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView164 = texture21.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup19, new Uint32Array(435), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer14, 'uint16', 8, 2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup3, []); |
| } catch {} |
| try { |
| commandEncoder156.copyTextureToTexture({ |
| texture: texture111, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline30 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| let bindGroup57 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 41, resource: {buffer: buffer155, size: 652}}, |
| {binding: 99, resource: {buffer: buffer138}}, |
| {binding: 51, resource: {buffer: buffer138}}, |
| {binding: 445, resource: sampler28}, |
| {binding: 4, resource: textureView120}, |
| {binding: 317, resource: externalTexture13}, |
| ], |
| }); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup50); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer135, 24, new Float64Array(10599).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/10597)), 76, 12); |
| } catch {} |
| let pipeline31 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}}); |
| let commandEncoder169 = device0.createCommandEncoder({}); |
| let textureView165 = texture38.createView({dimension: 'cube', baseArrayLayer: 2}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(5, buffer140, 4, 7); |
| } catch {} |
| let texture172 = device0.createTexture({ |
| size: [128], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 94.60, |
| }); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup0, new Uint32Array(2132), 471, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer126, 'uint32', 32, 19); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(4, buffer141); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer73, 8, 6); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer152, 'uint32', 100, 58); |
| } catch {} |
| let commandEncoder170 = device1.createCommandEncoder({}); |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 37, height: 5, depthOrArrayLayers: 82} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 0, y: 15 }, |
| flipY: false, |
| }, { |
| texture: texture161, |
| mipLevel: 2, |
| origin: {x: 2, y: 3, z: 6}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView166 = texture157.createView({baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup48, [0]); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout15 = pipeline10.getBindGroupLayout(0); |
| let commandEncoder171 = device0.createCommandEncoder({}); |
| let sampler30 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMinClamp: 80.90, lodMaxClamp: 92.74}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup44, []); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup1); |
| } catch {} |
| let pipeline32 = device0.createRenderPipeline({ |
| label: '\u{1f84f}\u3b62\u0991\u394b\u{1f725}\u9cee', |
| layout: 'auto', |
| fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg32uint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule6, |
| constants: {override12: 1}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x2', offset: 0, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 4}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 6}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 14}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 1}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 7}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 2}, |
| {format: 'sint8x2', offset: 4, shaderLocation: 12}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 0}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'ccw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let texture173 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| await gc(); |
| let buffer158 = device1.createBuffer({size: 212, usage: GPUBufferUsage.STORAGE, mappedAtCreation: false}); |
| let texture174 = device1.createTexture({ |
| size: {width: 150}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView167 = texture153.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1}); |
| let sampler31 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.07, |
| maxAnisotropy: 16, |
| }); |
| let externalTexture23 = device1.importExternalTexture({source: videoFrame9}); |
| let textureView168 = texture174.createView({}); |
| let renderPassEncoder25 = commandEncoder170.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView166, |
| depthSlice: 138, |
| clearValue: { r: -895.9, g: -446.5, b: -936.0, a: -885.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView135, |
| depthClearValue: -9.983658358191516, |
| depthReadOnly: true, |
| stencilLoadOp: 'load', |
| stencilStoreOp: 'store', |
| }, |
| maxDrawCount: 376286741, |
| }); |
| try { |
| renderBundleEncoder34.setVertexBuffer(2, buffer157); |
| } catch {} |
| try { |
| device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer129.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'hlg'} }); |
| let bindGroup58 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 445, resource: sampler27}, |
| {binding: 4, resource: textureView119}, |
| {binding: 51, resource: {buffer: buffer139}}, |
| {binding: 317, resource: externalTexture17}, |
| {binding: 41, resource: {buffer: buffer155, size: 472}}, |
| {binding: 99, resource: {buffer: buffer124, size: 92}}, |
| ], |
| }); |
| let buffer159 = device1.createBuffer({size: 488, usage: GPUBufferUsage.INDEX}); |
| let texture175 = device1.createTexture({ |
| size: {width: 150, height: 20, depthOrArrayLayers: 9}, |
| mipLevelCount: 4, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView169 = texture157.createView({format: 'rgba32sint', mipLevelCount: 1, arrayLayerCount: 1}); |
| let externalTexture24 = device1.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup51, new Uint32Array(2533), 106, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder32.setVertexBuffer(0, buffer110, 8, 15); |
| } catch {} |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt709', transfer: 'smpte240m'} }); |
| let bindGroup59 = device1.createBindGroup({layout: autogeneratedBindGroupLayout12, entries: [{binding: 4, resource: textureView113}]}); |
| let commandEncoder173 = device1.createCommandEncoder({}); |
| let texture176 = device1.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 39}, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView170 = texture131.createView({baseArrayLayer: 4, arrayLayerCount: 10}); |
| try { |
| renderBundleEncoder32.setBindGroup(1, bindGroup55); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(3, bindGroup50, new Uint32Array(1215), 422, 0); |
| } catch {} |
| let commandEncoder174 = device1.createCommandEncoder(); |
| let textureView171 = texture131.createView({dimension: '2d', format: 'rgba16float', mipLevelCount: 1, baseArrayLayer: 6}); |
| let computePassEncoder36 = commandEncoder144.beginComputePass(); |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer159, 'uint32', 188, 66); |
| } catch {} |
| try { |
| buffer113.unmap(); |
| } catch {} |
| let pipeline33 = await promise20; |
| let buffer160 = device1.createBuffer({size: 72, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let texture177 = device1.createTexture({ |
| size: [37, 5, 82], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup52, new Uint32Array(697), 222, 1); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline22); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'unspecified', transfer: 'smpte240m'} }); |
| let buffer161 = device0.createBuffer({ |
| size: 6368, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture178 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 84}, |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup16, new Uint32Array(880), 62, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let videoFrame23 = videoFrame3.clone(); |
| let buffer162 = device1.createBuffer({size: 16, usage: GPUBufferUsage.INDEX}); |
| let texture179 = device1.createTexture({size: [300], dimension: '1d', format: 'rgba32sint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView172 = texture135.createView({label: '\u{1fa52}\uefd1\ud868', dimension: '2d', baseArrayLayer: 1}); |
| let computePassEncoder37 = commandEncoder143.beginComputePass(); |
| try { |
| computePassEncoder36.setPipeline(pipeline31); |
| } catch {} |
| let texture180 = device1.createTexture({ |
| size: [300, 40, 33], |
| dimension: '2d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder37.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(0, buffer110, 0, 4); |
| } catch {} |
| let videoFrame24 = new VideoFrame(videoFrame23, {timestamp: 0}); |
| let buffer163 = device0.createBuffer({size: 152, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let textureView173 = texture81.createView({format: 'rg32uint'}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup16); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 1, resource: sampler5}, {binding: 70, resource: {buffer: buffer99, offset: 0, size: 294}}], |
| }); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| try { |
| buffer45.unmap(); |
| } catch {} |
| try { |
| commandEncoder76.pushDebugGroup('\ub84a'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 32, new Float32Array(59229).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.148)), 455, 8); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(27); }; |
| } catch {} |
| let texture181 = device1.createTexture({ |
| size: {width: 37, height: 5, depthOrArrayLayers: 82}, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView174 = texture141.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup48, [0]); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(1, buffer110, 0, 6); |
| } catch {} |
| try { |
| commandEncoder174.copyBufferToTexture({ |
| /* bytesInLastRow: 37 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 88 */ |
| offset: 88, |
| bytesPerRow: 64000, |
| buffer: buffer129, |
| }, { |
| texture: texture141, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 37, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer124, 8, new Float16Array(32762).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.250)), 6791, 8); |
| } catch {} |
| let imageData29 = new ImageData(16, 16); |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| let textureView175 = texture58.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 8, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer14, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(0, bindGroup23, []); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(0, buffer79, 0, 0); |
| } catch {} |
| try { |
| commandEncoder76.popDebugGroup(); |
| } catch {} |
| let commandEncoder178 = device1.createCommandEncoder({}); |
| let texture182 = device1.createTexture({ |
| size: [150, 20, 20], |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture183 = device1.createTexture({ |
| size: [37, 5, 1], |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView176 = texture155.createView({dimension: '2d-array'}); |
| let renderBundleEncoder36 = device1.createRenderBundleEncoder({colorFormats: ['rgba32float'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup48, [0]); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(0, buffer110); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup51); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(3, buffer105, 0, 37); |
| } catch {} |
| try { |
| commandEncoder147.copyTextureToTexture({ |
| texture: texture156, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture157, |
| mipLevel: 1, |
| origin: {x: 1, y: 1, z: 6}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 11}); |
| } catch {} |
| try { |
| commandEncoder133.resolveQuerySet(querySet3, 56, 0, buffer129, 0); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup61 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 186, resource: {buffer: buffer98}}, |
| {binding: 7, resource: {buffer: buffer161}}, |
| {binding: 5, resource: {buffer: buffer98}}, |
| ], |
| }); |
| let textureView177 = texture164.createView({}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup60); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup2, new Uint32Array(1001), 129, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame24, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 6, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(33); }; |
| } catch {} |
| let texture184 = device0.createTexture({ |
| size: {width: 15}, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler32 = device0.createSampler({ |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 88.09, |
| compare: 'always', |
| maxAnisotropy: 4, |
| }); |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| let textureView178 = texture184.createView({baseArrayLayer: 0}); |
| let texture185 = device0.createTexture({ |
| size: {width: 120, height: 120, depthOrArrayLayers: 49}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler33 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge', minFilter: 'nearest'}); |
| try { |
| device0.queue.writeBuffer(buffer102, 4, new Uint16Array(2402).map((_, i) => i + 0), 358, 0); |
| } catch {} |
| let textureView179 = texture63.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder9.beginOcclusionQuery(158); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| buffer100.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer93, 32, new Uint32Array(14887).map((_, i) => i * 4), 2828, 12); |
| } catch {} |
| let bindGroup62 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer138}}, |
| {binding: 4, resource: textureView113}, |
| {binding: 44, resource: {buffer: buffer124, size: 28}}, |
| ], |
| }); |
| let texture186 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 45}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture187 = device1.createTexture({ |
| size: {width: 150, height: 20, depthOrArrayLayers: 85}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler34 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 99.61, |
| compare: 'not-equal', |
| }); |
| try { |
| renderBundleEncoder36.setVertexBuffer(1, buffer157); |
| } catch {} |
| try { |
| commandEncoder152.resolveQuerySet(querySet3, 14, 1, buffer129, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device1, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| let texture188 = device0.createTexture({ |
| size: [120, 120, 26], |
| dimension: '2d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline32); |
| } catch {} |
| let promise26 = device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule6}}); |
| let bindGroup63 = device0.createBindGroup({layout: autogeneratedBindGroupLayout13, entries: [{binding: 0, resource: {buffer: buffer98}}]}); |
| let textureView180 = texture108.createView({}); |
| let renderPassEncoder26 = commandEncoder58.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView81, |
| clearValue: { r: 858.5, g: 442.5, b: 830.9, a: 724.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 4294967295}, |
| }); |
| let texture189 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup34); |
| } catch {} |
| try { |
| buffer17.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout16 = pipeline28.getBindGroupLayout(0); |
| let commandEncoder180 = device1.createCommandEncoder({}); |
| let texture190 = device1.createTexture({ |
| size: {width: 300, height: 40, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture191 = device1.createTexture({ |
| size: {width: 75, height: 10, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup50, new Uint32Array(10000), 1_356, 0); |
| } catch {} |
| let img2 = await imageWithData(15, 2, '#10101010', '#20202020'); |
| let buffer164 = device0.createBuffer({size: 296, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder6.setPipeline(pipeline7); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 122, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 123, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 256, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 325, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 372, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup64 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer88}}, |
| {binding: 43, resource: textureView3}, |
| {binding: 11, resource: {buffer: buffer53}}, |
| {binding: 229, resource: {buffer: buffer143}}, |
| ], |
| }); |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| let texture192 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture193 = gpuCanvasContext4.getCurrentTexture(); |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup61, new Uint32Array(5032), 1_332, 1); |
| } catch {} |
| let shaderModule9 = device1.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| @id(36447) override override21: u32 = (1259402612 % 103) + 1; |
| |
| @id(1843) override override28: u32; |
| |
| struct VertexOutput7 { |
| @location(13) location_13: f32, |
| @location(4) location_4: f16, |
| @location(12) @interpolate(flat, either) location_12: f32, |
| @location(11) @interpolate(flat, first) location_11: f16, |
| @location(6) location_6: i32, |
| @invariant @builtin(position) position: vec4f, |
| } |
| |
| override override27: i32; |
| |
| override override30: u32; |
| |
| override override31 = 0.1136; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T1 { |
| @align(8) @size(1192) f0: atomic<i32>, |
| } |
| |
| @id(5515) override override29: f16; |
| |
| struct VertexInput41 { |
| @location(8) location_8: vec4h, |
| @location(2) @interpolate(flat, first) location_2: i32, |
| @location(15) @interpolate(linear, first) location_15: vec4f, |
| @location(5) location_5: f32, |
| @location(10) @interpolate(perspective) location_10: f32, |
| @location(13) location_13: u32, |
| @location(12) location_12: u32, |
| @location(14) location_14: vec2i, |
| @location(0) @interpolate(flat, center) location_0: vec2u, |
| @location(7) @interpolate(flat, sample) location_7: vec2i, |
| @location(9) location_9: vec2i, |
| } |
| |
| @group(1) @binding(2) var<uniform> buffer166: array<array<vec4i, 74>, 1>; |
| |
| struct FragmentOutput8 { |
| @location(0) location_0: vec4i, |
| @location(1) @interpolate(flat) location_1: i32, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| @id(51159) override override19: u32; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| f0: vec2i, |
| @size(32) f1: vec4f, |
| @size(1152) f2: array<array<vec4<bool>, 1>, 36>, |
| } |
| |
| override override22: u32 = (1578275560 % 103) + 1; |
| |
| struct VertexInput42 { |
| @location(6) @interpolate(flat, sample) location_6: vec4h, |
| @location(1) location_1: vec2i, |
| @location(11) location_11: vec4i, |
| } |
| |
| @id(48752) override override24: f32; |
| |
| @id(18494) override override25: f16; |
| |
| @group(0) @binding(2) var<uniform> buffer165: array<vec4u, 1>; |
| |
| @id(40512) override override23: f16 = 57215.7; |
| |
| override override26: i32 = 725336450; |
| |
| @id(51398) override override20: f16; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct FragmentInput18 { |
| @location(13) location_13: f32, |
| } |
| |
| var<workgroup> vw12: atomic<u32>; |
| |
| struct FragmentInput19 { |
| @location(6) location_6: i32, |
| @location(4) location_4: f16, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| @vertex @must_use |
| fn vertex8(a0: VertexInput41, a1: VertexInput42, @builtin(vertex_index) vertex_index: u32) -> VertexOutput7 { |
| var out: VertexOutput7; |
| let vf92: vec4h = a0.location_8; |
| out.location_6 *= i32(out.position[bitcast<u32>(out.location_13)]); |
| let vf93: u32 = vertex_index; |
| var vf94: f16 = sign(unconst_f16(1848.3)); |
| let vf95: vec3f = exp(vec3f(unconst_f32(0.00427), unconst_f32(0.1251), unconst_f32(0.1868e4))); |
| switch u32(exp2(f32(vertex_index))) { |
| case default { |
| out.location_12 *= f32(out.location_11); |
| out.location_12 = bitcast<vec2f>(a0.location_0.xy).y; |
| out.location_11 += vec4h(a1.location_11)[2]; |
| let vf96: vec2i = a0.location_9; |
| while bool(a0.location_8.x) { |
| let vf97: u32 = a0.location_12; |
| break; |
| } |
| break; |
| } |
| } |
| var vf98: f16 = vf92[unconst_u32(181535772)]; |
| return out; |
| } |
| |
| /* used global variables: buffer166 */ |
| @fragment |
| fn fragment10() -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| out.location_0 += vec4i(buffer166[0][73][unconst_u32(418748964)]); |
| out.sample_mask &= u32((*&buffer166)[0][unconst_u32(520913729)].b); |
| var vf99: i32 = (*&buffer166)[0][unconst_u32(564656836)][unconst_u32(343982410)]; |
| let vf100: vec2f = asinh(vec2f(unconst_f32(0.7009), unconst_f32(0.3772))); |
| let ptr102: ptr<uniform, vec4i> = &(*&buffer166)[0][73]; |
| out.location_0 &= vec4i(bitcast<i32>(out.sample_mask)); |
| return out; |
| _ = buffer166; |
| } |
| |
| /* used global variables: buffer165, buffer166 */ |
| @fragment |
| fn fragment11(a0: FragmentInput18, a1: FragmentInput19) -> @location(200) @interpolate(flat, either) vec4i { |
| var out: vec4i; |
| var vf101: i32 = a1.location_6; |
| vf101 *= buffer166[0][73].b; |
| var vf102: FragmentInput18 = a0; |
| let vf103: u32 = pack2x16snorm(vec2f(unconst_f32(0.1147e-10), unconst_f32(0.02754e-30))); |
| vf101 &= i32(faceForward(vec2f(unconst_f32(0.4551), unconst_f32(0.3337)), vec2f(unconst_f32(0.1083e-2), unconst_f32(0.1104e19)), vec2f(unconst_f32(0.09721e26), unconst_f32(-0.07104)))[1]); |
| out = vec4i(buffer165[unconst_u32(1781595795)]); |
| let vf104: vec4h = sin(vec4h(override25)); |
| let vf105: ptr<uniform, array<array<vec4i, 74>, 1>> = &buffer166; |
| var vf106: u32 = buffer165[unconst_u32(196724940)][unconst_u32(960918)]; |
| return out; |
| _ = override25; |
| _ = buffer166; |
| _ = buffer165; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 2) |
| fn compute8(@builtin(workgroup_id) workgroup_id: vec3u) { |
| atomicCompareExchangeWeak(&vw12, unconst_u32(874897625), unconst_u32(1150405260)); |
| var vf107: vec3f = asin(vec3f(unconst_f32(0.1848), unconst_f32(0.05716e-13), unconst_f32(0.04488))); |
| let vf108: f32 = vf107[unconst_u32(431460110)]; |
| var vf109: u32 = override19; |
| let vf110: f32 = override24; |
| let vf111: vec2u = firstLeadingBit(vec2u(unconst_u32(551490505), unconst_u32(746514525))); |
| vf109 -= u32((unconst_bool(true) || unconst_bool(true))); |
| vf109 <<= vec3u(asin(vec3f(unconst_f32(0.04215), unconst_f32(0.1649e15), unconst_f32(0.05276))).xxz)[1]; |
| _ = override24; |
| _ = override19; |
| }`, |
| }); |
| let bindGroup65 = device1.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 4, resource: textureView110}]}); |
| let buffer167 = device1.createBuffer({size: 2344, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView181 = texture131.createView({baseMipLevel: 0, baseArrayLayer: 4, arrayLayerCount: 3}); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup51, new Uint32Array(368), 37, 0); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup54, []); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer145, 'uint16', 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(0, buffer110); |
| } catch {} |
| try { |
| renderBundleEncoder34.setVertexBuffer(4, buffer105, 44); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer105, 60, new Float64Array(3165).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/3162)), 250, 4); |
| } catch {} |
| let texture194 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup40, new Uint32Array(47), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder35.setVertexBuffer(0, buffer75); |
| } catch {} |
| let texture195 = device1.createTexture({ |
| size: [150, 20, 1], |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView182 = texture157.createView({aspect: 'all', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| renderPassEncoder25.setPipeline(pipeline20); |
| } catch {} |
| let videoFrame25 = new VideoFrame(videoFrame23, {timestamp: 0}); |
| let texture196 = device0.createTexture({size: [128], dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup14, new Uint32Array(1478), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline4); |
| } catch {} |
| let commandEncoder182 = device0.createCommandEncoder({}); |
| let texture197 = device0.createTexture({ |
| size: [30], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let pipeline34 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder16.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(0, undefined); |
| } catch {} |
| try { |
| commandEncoder99.resolveQuerySet(querySet1, 68, 56, buffer25, 2560); |
| } catch {} |
| try { |
| renderBundleEncoder5.insertDebugMarker('\u0f49'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer142, 48, new BigInt64Array(14012).map((_, i) => BigInt(i - 6)), 3121, 16); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer102, 'uint16', 80, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(56); }; |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpteRp431', transfer: 'logSqrt'} }); |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let texture198 = device0.createTexture({ |
| size: [128, 128, 26], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer47, 'uint16', 40, 11); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(1, buffer104, 0); |
| } catch {} |
| try { |
| commandEncoder179.copyBufferToBuffer(buffer59, 20, buffer70, 44, 8); |
| } catch {} |
| try { |
| commandEncoder96.copyTextureToTexture({ |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 4, y: 2, z: 11}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture163, |
| mipLevel: 0, |
| origin: {x: 6, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView183 = texture190.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder33.setBindGroup(2, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup57, new Uint32Array(1624), 127, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline20); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer125, 0, new Float32Array(3451).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.765)), 69, 4); |
| } catch {} |
| document.body.append(img0); |
| let texture199 = device1.createTexture({ |
| size: {width: 75}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup48, [0]); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup51, new Uint32Array(2923), 115, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer145, 'uint32', 4, 12); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer159, 'uint32', 88, 104); |
| } catch {} |
| try { |
| computePassEncoder34.insertDebugMarker('\u02a5'); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer138, 28, new Uint32Array(2117).map((_, i) => i * 4), 90, 0); |
| } catch {} |
| let promise27 = device1.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(34); }; |
| } catch {} |
| try { |
| await promise27; |
| } catch {} |
| let bindGroup66 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 4, resource: textureView110}, |
| {binding: 44, resource: {buffer: buffer106}}, |
| {binding: 0, resource: {buffer: buffer138}}, |
| ], |
| }); |
| let commandEncoder185 = device1.createCommandEncoder({}); |
| let textureView184 = texture181.createView({dimension: '3d'}); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup66, new Uint32Array(298), 95, 1); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline20); |
| } catch {} |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 69, y: 11 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer168 = device1.createBuffer({size: 374, usage: GPUBufferUsage.MAP_WRITE}); |
| let texture200 = device1.createTexture({ |
| size: {width: 37}, |
| dimension: '1d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder27 = commandEncoder162.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView169, |
| depthSlice: 24, |
| clearValue: { r: -319.4, g: 790.3, b: 845.2, a: -172.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView124, |
| depthClearValue: 2.536641816084959, |
| depthReadOnly: true, |
| stencilLoadOp: 'load', |
| stencilStoreOp: 'store', |
| }, |
| occlusionQuerySet: querySet3, |
| maxDrawCount: 265901232, |
| }); |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup55, new Uint32Array(1620), 57, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer160, 'uint32', 0, 38); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| let buffer169 = device1.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder187 = device1.createCommandEncoder({}); |
| let bindGroup67 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 44, resource: {buffer: buffer106}}, |
| {binding: 0, resource: {buffer: buffer109}}, |
| {binding: 4, resource: textureView151}, |
| ], |
| }); |
| let texture201 = device1.createTexture({ |
| size: [300, 40, 1], |
| mipLevelCount: 3, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup54, new Uint32Array(1809), 284, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer159, 'uint16', 4, 137); |
| } catch {} |
| try { |
| renderBundleEncoder32.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(6, buffer169); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(33); }; |
| } catch {} |
| let textureView185 = texture154.createView({}); |
| try { |
| renderPassEncoder20.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder6.beginOcclusionQuery(132); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer170 = device1.createBuffer({ |
| size: 32, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture202 = device1.createTexture({ |
| size: [37], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder27.setPipeline(pipeline20); |
| } catch {} |
| try { |
| buffer138.unmap(); |
| } catch {} |
| await gc(); |
| let bindGroup68 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 4, resource: textureView151}, |
| {binding: 44, resource: {buffer: buffer109}}, |
| {binding: 0, resource: {buffer: buffer135}}, |
| ], |
| }); |
| let textureView186 = texture186.createView({dimension: '2d', format: 'rgba8uint', baseArrayLayer: 3}); |
| let renderPassEncoder28 = commandEncoder152.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView169, |
| depthSlice: 457, |
| clearValue: { r: 155.3, g: 592.2, b: -470.5, a: 852.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView157, |
| depthClearValue: -2.698382323384636, |
| stencilClearValue: 48755, |
| stencilLoadOp: 'load', |
| stencilStoreOp: 'discard', |
| }, |
| maxDrawCount: 372776726, |
| }); |
| try { |
| renderPassEncoder28.setVertexBuffer(2, buffer169, 24); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(6, buffer105, 0, 29); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let promise28 = device1.queue.onSubmittedWorkDone(); |
| let commandEncoder188 = device1.createCommandEncoder({}); |
| let textureView187 = texture181.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer162, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup59); |
| } catch {} |
| try { |
| computePassEncoder35.setBindGroup(3, bindGroup62, [0]); |
| } catch {} |
| try { |
| commandEncoder140.copyTextureToBuffer({ |
| texture: texture191, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 176 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 16 */ |
| offset: 16, |
| buffer: buffer130, |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise28; |
| } catch {} |
| let bindGroup69 = device1.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 0, resource: {buffer: buffer124, size: 48}}, {binding: 4, resource: textureView113}], |
| }); |
| let commandEncoder189 = device1.createCommandEncoder({}); |
| let texture203 = device1.createTexture({ |
| size: [37, 5, 42], |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup55); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device1, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'}); |
| } catch {} |
| let promise29 = device1.queue.onSubmittedWorkDone(); |
| let commandEncoder190 = device1.createCommandEncoder({}); |
| try { |
| renderPassEncoder27.setVertexBuffer(0, buffer110, 16, 16); |
| } catch {} |
| try { |
| renderBundleEncoder32.setPipeline(pipeline22); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let buffer171 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer95.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 120, height: 120, depthOrArrayLayers: 49} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 17, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let texture204 = device0.createTexture({ |
| size: {width: 80, height: 60, depthOrArrayLayers: 22}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer48); |
| } catch {} |
| try { |
| commandEncoder118.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 444 */ |
| offset: 444, |
| bytesPerRow: 49920, |
| buffer: buffer136, |
| }, { |
| texture: texture126, |
| mipLevel: 0, |
| origin: {x: 9, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let textureView188 = texture140.createView({aspect: 'stencil-only', format: 'stencil8', baseMipLevel: 3, baseArrayLayer: 53, arrayLayerCount: 7}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup57); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup59, new Uint32Array(2930), 629, 0); |
| } catch {} |
| try { |
| commandEncoder163.resolveQuerySet(querySet3, 58, 8, buffer129, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.insertDebugMarker('\u5699'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device1, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'}); |
| } catch {} |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| let textureView189 = texture204.createView({baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 1}); |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder6.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setStencilReference(80); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder74.copyTextureToBuffer({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 9, y: 3, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 476 */ |
| offset: 476, |
| bytesPerRow: 12800, |
| buffer: buffer93, |
| }, {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer172 = device0.createBuffer({size: 164, usage: GPUBufferUsage.INDIRECT}); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup31); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup2, new Uint32Array(553), 113, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup12, new Uint32Array(5427), 76, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(2, buffer73, 0, 9); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let texture205 = device0.createTexture({ |
| size: {width: 20, height: 15, depthOrArrayLayers: 82}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer101, 0); }; |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup0, new Uint32Array(192), 11, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer48, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer161, 256, new DataView(new ArrayBuffer(34516)), 2324, 312); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout13, |
| entries: [{binding: 0, resource: {buffer: buffer98, offset: 0}}], |
| }); |
| let texture206 = device0.createTexture({ |
| size: [128, 128, 55], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer58); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise29; |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 11, resource: {buffer: buffer68}}, |
| {binding: 229, resource: {buffer: buffer141, size: 160}}, |
| {binding: 43, resource: textureView3}, |
| {binding: 4, resource: {buffer: buffer161, offset: 1024}}, |
| ], |
| }); |
| let commandEncoder195 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder18.insertDebugMarker('\u0726'); |
| } catch {} |
| let imageData30 = new ImageData(44, 56); |
| let renderPassEncoder29 = commandEncoder153.beginRenderPass({ |
| colorAttachments: [{view: textureView182, depthSlice: 41, loadOp: 'clear', storeOp: 'store'}], |
| depthStencilAttachment: { |
| view: textureView135, |
| depthClearValue: 3.358017438512338, |
| depthReadOnly: true, |
| stencilClearValue: 58906, |
| stencilLoadOp: 'clear', |
| stencilStoreOp: 'store', |
| }, |
| }); |
| try { |
| renderPassEncoder27.setBindGroup(3, bindGroup54); |
| } catch {} |
| let buffer173 = device0.createBuffer({ |
| size: 128, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder196 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer12, 'uint16', 10, 15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer152, 52, new Float32Array(9324).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.08901)), 673, 0); |
| } catch {} |
| let buffer174 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let texture207 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView190 = texture119.createView({dimension: '2d', baseArrayLayer: 1}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer12, 'uint16', 38, 6); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder35.setVertexBuffer(5, buffer17, 168); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(imageData29); |
| let texture208 = device0.createTexture({size: [120, 120, 77], format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(643), 20, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| commandEncoder122.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 16 */ |
| offset: 16, |
| bytesPerRow: 22528, |
| buffer: buffer46, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 46, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 398, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| {binding: 509, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let textureView191 = texture192.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup47, new Uint32Array(3607), 841, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img1); |
| let bindGroup72 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer157}}, |
| {binding: 4, resource: textureView110}, |
| {binding: 44, resource: {buffer: buffer155, size: 18}}, |
| ], |
| }); |
| let renderPassEncoder30 = commandEncoder189.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView169, |
| depthSlice: 171, |
| clearValue: { r: -100.8, g: -621.4, b: 612.6, a: -43.42, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView111, |
| depthClearValue: -5.550927288094762, |
| depthReadOnly: true, |
| stencilClearValue: 6233, |
| stencilLoadOp: 'clear', |
| stencilStoreOp: 'discard', |
| }, |
| }); |
| try { |
| computePassEncoder33.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(2, bindGroup58); |
| } catch {} |
| try { |
| device1.pushErrorScope('validation'); |
| } catch {} |
| let commandBuffer1 = commandEncoder46.finish({}); |
| let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup37, new Uint32Array(79), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(6, buffer141, 0, 29); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let shaderModule10 = device1.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| var<private> vp9: vec2f = vec2f(0.03266, 0.02863e15); |
| |
| @id(46802) override override33 = true; |
| |
| @id(45647) override override41: i32; |
| |
| struct T7 { |
| @size(30) f0: u32, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct ComputeInput11 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @id(7427) override override32 = -447781511; |
| |
| struct VertexInput51 { |
| @location(15) location_15: vec4i, |
| } |
| |
| struct VertexInput45 { |
| @location(10) @interpolate(flat) location_10: i32, |
| @location(4) @interpolate(flat, center) location_4: vec2i, |
| } |
| |
| @group(0) @binding(4) var tex16: texture_cube<f32>; |
| |
| @group(0) @binding(0) var<storage, read_write> buffer175: array<array<array<f16, 1>, 15>>; |
| |
| struct VertexInput43 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct FragmentInput24 { |
| @location(11) @interpolate(linear, either) location_11: f16, |
| } |
| |
| struct T2 { |
| @size(16) f0: atomic<i32>, |
| } |
| |
| struct VertexInput49 { |
| @location(14) @interpolate(flat) location_14: i32, |
| } |
| |
| struct VertexInput48 { |
| @location(9) location_9: u32, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput46 { |
| @location(3) @interpolate(flat) location_3: vec4i, |
| } |
| |
| @id(45152) override override38 = true; |
| |
| /* used global variables: buffer175 */ |
| fn fn1(a0: ptr<uniform, vec4i>) -> vec4h { |
| var out: vec4h; |
| buffer175[unconst_u32(339588008)][unconst_u32(257941665)][unconst_u32(651631806)] *= f16(vp10[unconst_u32(118318535)][0]); |
| return out; |
| _ = buffer175; |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexInput47 { |
| @location(11) @interpolate(flat) location_11: f32, |
| @location(6) location_6: i32, |
| } |
| |
| struct FragmentInput20 { |
| @builtin(front_facing) front_facing: bool, |
| @location(1) @interpolate(flat, centroid) location_1: vec4i, |
| @location(10) @interpolate(flat, centroid) location_10: i32, |
| } |
| |
| @id(23986) override override37: f16 = 201.0; |
| |
| /* used global variables: tex16 */ |
| fn fn0(a0: ptr<storage, f16, read_write>) { |
| vp11 = vec2<bool>(vp10[0].gg.yy.yx); |
| let vf112: u32 = pack4xI8(vec4i(i32(all(unconst_bool(true))))); |
| var vf113: vec2u = textureDimensions(tex16); |
| _ = tex16; |
| } |
| |
| struct T9 { |
| f0: array<u32>, |
| } |
| |
| struct FragmentInput22 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| var<private> vp10: array<vec2i, 1> = array(vec2i(99448690, 677888539)); |
| |
| override override34: bool; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct VertexInput44 { |
| @location(0) location_0: vec4f, |
| @builtin(instance_index) instance_index: u32, |
| @location(2) location_2: vec4i, |
| @location(5) @interpolate(perspective) location_5: vec4f, |
| @location(7) @interpolate(flat) location_7: u32, |
| @location(1) location_1: vec4h, |
| } |
| |
| struct FragmentInput23 { |
| @location(3) location_3: vec2f, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct FragmentInput26 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| @id(34209) override override44: f16; |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| struct T4 { |
| f0: array<T2>, |
| } |
| |
| struct FragmentInput21 { |
| @location(0) @interpolate(perspective, first) location_0: vec4h, |
| @location(5) location_5: i32, |
| } |
| |
| struct T6 { |
| @size(30) f0: T0, |
| } |
| |
| override override39: f16; |
| |
| struct ComputeInput9 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| @id(3870) override override40: i32 = 283501832; |
| |
| struct T1 { |
| f0: vec2h, |
| f1: f16, |
| @size(24) f2: atomic<i32>, |
| } |
| |
| struct T8 { |
| f0: array<array<atomic<i32>, 1>>, |
| } |
| |
| override override36 = true; |
| |
| struct ComputeInput10 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct T0 { |
| @size(16) f0: atomic<u32>, |
| } |
| |
| @group(0) @binding(44) var<uniform> buffer176: array<VertexInput46, 1>; |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn2(a0: texture_cube<f32>) -> array<array<array<i32, 1>, 1>, 1> { |
| var out: array<array<array<i32, 1>, 1>, 1>; |
| for (var it7=u32(override38); it7<(vec3u((vec3i(unconst_i32(295706207), unconst_i32(1262880401), unconst_i32(34778298)) >> vec3u(unconst_u32(316779928), unconst_u32(1453398000), unconst_u32(166676734))).ggg)[2] & 0xfff); it7++) { |
| vp11 = !vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(true)).aa; |
| } |
| let vf114: bool = override35; |
| vp9 *= vec2f(bitcast<f32>(out[0][0][0])); |
| let ptr103: ptr<function, i32> = &out[0][0][textureNumLevels(a0)]; |
| let ptr104: ptr<function, i32> = &out[unconst_u32(432865095)][0][unconst_u32(1212652215)]; |
| return out; |
| _ = override38; |
| _ = override35; |
| } |
| |
| struct FragmentInput25 { |
| @builtin(position) position: vec4f, |
| } |
| |
| override override43: i32 = 111996250; |
| |
| var<private> vp11: vec2<bool> = vec2<bool>(true, false); |
| |
| @id(49653) override override42: bool; |
| |
| struct VertexOutput8 { |
| @location(15) @interpolate(flat) location_15: vec4h, |
| @location(4) location_4: vec2i, |
| @location(0) location_0: f16, |
| @location(10) @interpolate(flat, either) location_10: f32, |
| @location(12) location_12: u32, |
| @invariant @builtin(position) position: vec4f, |
| } |
| |
| override override35: bool; |
| |
| struct FragmentOutput9 { |
| @location(0) @interpolate(flat) location_0: vec4i, |
| } |
| |
| struct VertexInput50 { |
| @location(8) location_8: i32, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex9(a0: VertexInput43, a1: VertexInput44, a2: VertexInput45, a3: VertexInput46, a4: VertexInput47, a5: VertexInput48, @location(12) location_12: f32, @location(13) location_13: vec2u, a8: VertexInput49, a9: VertexInput50, a10: VertexInput51) -> VertexOutput8 { |
| var out: VertexOutput8; |
| let ptr105: ptr<function, vec2i> = &out.location_4; |
| let vf115: vec3<bool> = (vec3h(unconst_f16(2314.5), unconst_f16(20091.9), unconst_f16(7313.4)) < vec3h(unconst_f16(32217.7), unconst_f16(4278.3), unconst_f16(25575.2))); |
| switch a3.location_3[1] { |
| case default { |
| out.location_15 = vec4h(a10.location_15.abar); |
| var vf116: vec4<bool> = (vec4h(unconst_f16(9090.6), unconst_f16(1412.8), unconst_f16(1109.9), unconst_f16(8995.3)) > vec4h(unconst_f16(-16131.4), unconst_f16(1607.4), unconst_f16(8263.2), unconst_f16(26676.6))); |
| out.position = bitcast<vec4f>(a1.location_2.abbr); |
| let ptr106: ptr<private, vec2i> = &vp10[0]; |
| let ptr107: ptr<function, vec4h> = &out.location_15; |
| out.location_10 = a4.location_11; |
| } |
| case 461077801: { |
| let vf117: f32 = a4.location_11; |
| var vf118: vec4i = a3.location_3; |
| var vf119: vec2f = unpack2x16float(vec3u(transpose(mat3x4h(unconst_f16(4494.4), unconst_f16(7787.0), unconst_f16(6547.2), unconst_f16(2182.5), unconst_f16(7663.6), unconst_f16(9889.5), unconst_f16(3251.1), unconst_f16(16277.0), unconst_f16(5789.0), unconst_f16(2722.3), unconst_f16(8840.4), unconst_f16(895.9)))[unconst_i32(1)].yyz.zxy.xzz).r); |
| var vf120: vec4f = log2(vec4f(unconst_f32(0.01395e-20), unconst_f32(0.2560e14), unconst_f32(0.00200), unconst_f32(0.01478))); |
| } |
| case 61733021, 477732659: { |
| switch u32(a10.location_15[unconst_u32(1043773733)]) { |
| case 444241839, default: { |
| let vf121: f32 = location_12; |
| out.location_0 = out.location_15.a; |
| } |
| } |
| break; |
| } |
| } |
| out.position = vec4f(out.location_15); |
| var vf122: VertexInput50 = a9; |
| out.position = vec4f(bitcast<f32>(pack4xI8(vec4i(unconst_i32(951933110), unconst_i32(122009523), unconst_i32(1202512285), unconst_i32(399283783))))); |
| let vf123: u32 = location_13[unconst_u32(340670924)]; |
| var vf124: VertexInput46 = a3; |
| out.position = vec4f(f32(max(unconst_f16(-18355.2), unconst_f16(4600.0)))); |
| return out; |
| } |
| |
| /* used global variables: buffer175, buffer176, tex16 */ |
| @fragment |
| fn fragment12(@location(14) @interpolate(flat, sample) location_14: u32, a1: FragmentInput20, a2: FragmentInput21, @location(12) location_12: vec2f, a4: FragmentInput22, a5: FragmentInput23, a6: FragmentInput24, @location(15) @interpolate(perspective) location_15: vec4h, a8: FragmentInput25, a9: FragmentInput26) -> FragmentOutput9 { |
| var out: FragmentOutput9; |
| var vf125 = fn2(tex16); |
| let ptr108: ptr<function, i32> = &vf125[0][unconst_u32(2215126008)][unconst_u32(688222159)]; |
| vp11 = vec2<bool>(a1.front_facing); |
| for (var it8=u32(vf125[0][unconst_u32(60387442)][unconst_u32(377354387)]); it8<(bitcast<u32>(vf125[0][0][0]) & 0xfff); it8++) { |
| var vf126 = fn1(&(*&buffer176)[unconst_u32(630805640)].location_3); |
| vp11 = vec2<bool>(buffer176[0].location_3.wz); |
| let ptr109: ptr<uniform, vec4i> = &buffer176[0].location_3; |
| _ = buffer175; |
| _ = buffer176; |
| } |
| return out; |
| _ = override38; |
| _ = override35; |
| _ = tex16; |
| _ = buffer176; |
| _ = buffer175; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute9(a0: ComputeInput9, a1: ComputeInput10, a2: ComputeInput11, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) { |
| var vf127: bool = vp11[unconst_u32(227704401)]; |
| vp11 = vec2<bool>(override36); |
| vp11 = vp11; |
| vp10[unconst_u32(792281408)] -= vec2i(a2.num_workgroups.xy); |
| var vf128: vec4u = unpack4xU8(unconst_u32(272610915)); |
| let vf129: vec3u = a1.global_invocation_id; |
| var vf130: i32 = vp10[unconst_u32(915927250)][unconst_u32(242695562)]; |
| vp9 = unpack2x16unorm(a0.workgroup_id[unconst_u32(6436458)]); |
| _ = override36; |
| }`, |
| }); |
| let textureView192 = texture202.createView({aspect: 'all'}); |
| let renderPassEncoder31 = commandEncoder180.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView169, |
| depthSlice: 384, |
| clearValue: { r: 331.1, g: -882.7, b: 860.7, a: 428.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView157, |
| depthClearValue: -4.281522679874346, |
| depthReadOnly: true, |
| stencilClearValue: 38582, |
| stencilLoadOp: 'clear', |
| stencilStoreOp: 'store', |
| }, |
| maxDrawCount: 171375516, |
| }); |
| let sampler35 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer160, 'uint16', 0, 13); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(3, buffer105, 0); |
| } catch {} |
| try { |
| buffer133.unmap(); |
| } catch {} |
| let buffer177 = device1.createBuffer({size: 260, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder199 = device1.createCommandEncoder({}); |
| let texture209 = device1.createTexture({ |
| size: {width: 75, height: 10, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView193 = texture147.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 4}); |
| let computePassEncoder38 = commandEncoder163.beginComputePass(); |
| let externalTexture25 = device1.importExternalTexture({source: videoFrame22}); |
| try { |
| computePassEncoder38.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(2, bindGroup62, new Uint32Array(3297), 385, 1); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer159, 'uint16', 488); |
| } catch {} |
| try { |
| renderBundleEncoder30.setPipeline(pipeline20); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline32); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 0, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(162).fill(160), /* required buffer size: 162 */ |
| {offset: 162}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: {buffer: buffer88}}, |
| {binding: 37, resource: {buffer: buffer68, offset: 0}}, |
| {binding: 436, resource: externalTexture1}, |
| ], |
| }); |
| let buffer178 = device0.createBuffer({size: 186, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let commandEncoder200 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer152, 'uint16', 86, 52); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer47, 'uint16', 14, 11); |
| } catch {} |
| try { |
| buffer75.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let pipeline35 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| document.body.append(canvas0); |
| let texture210 = device1.createTexture({ |
| size: {width: 300}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView194 = texture186.createView({baseArrayLayer: 17, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder31.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(0, bindGroup43, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder34.setVertexBuffer(3, buffer105, 80, 19); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer105, 124, new Float32Array(2090).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.590)), 210, 12); |
| } catch {} |
| let buffer179 = device0.createBuffer({size: 140, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let texture211 = device0.createTexture({ |
| size: {width: 15, height: 15, depthOrArrayLayers: 65}, |
| dimension: '2d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup63, new Uint32Array(1168), 445, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer60, 'uint16', 6, 6); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 1, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder201 = device1.createCommandEncoder({}); |
| let texture212 = device1.createTexture({ |
| size: {width: 37, height: 5, depthOrArrayLayers: 82}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup72, [0]); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup58, new Uint32Array(2160), 61, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer127, 12, new DataView(new ArrayBuffer(44132)), 238, 0); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 70, resource: {buffer: buffer128, offset: 0, size: 282}}], |
| }); |
| let texture213 = device0.createTexture({size: [30, 30, 12], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup74, new Uint32Array(1848), 446, 0); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer72, 'uint32', 28, 7); |
| } catch {} |
| let commandEncoder202 = device0.createCommandEncoder({}); |
| let sampler36 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear'}); |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer63, 16); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(2, bindGroup53, new Uint32Array(904), 393, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer128, 'uint16', 18, 18); |
| } catch {} |
| try { |
| buffer79.unmap(); |
| } catch {} |
| let textureView195 = texture180.createView({aspect: 'all', arrayLayerCount: 9}); |
| try { |
| renderPassEncoder28.setBindGroup(0, bindGroup54, []); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup59, new Uint32Array(4322), 342, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer162, 'uint16', 0, 0); |
| } catch {} |
| try { |
| commandEncoder185.copyTextureToBuffer({ |
| texture: texture190, |
| mipLevel: 0, |
| origin: {x: 6, y: 4, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 780 */ |
| offset: 780, |
| bytesPerRow: 3072, |
| buffer: buffer167, |
| }, {width: 1, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture183, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(585).fill(97), /* required buffer size: 585 */ |
| {offset: 585}, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| videoFrame2.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| } |
| async function window1() { |
| let adapter0 = await navigator.gpu.requestAdapter({powerPreference: 'high-performance'}); |
| let promise0 = navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| 'float32-blendable', |
| 'float16-renderable', |
| 'float32-renderable', |
| 'core-features-and-limits', |
| ], |
| requiredLimits: { |
| maxSampledTexturesPerShaderStage: 16, |
| maxStorageBufferBindingSize: 166673635, |
| maxTextureDimension2D: 8192, |
| maxUniformBufferBindingSize: 4211958, |
| maxVertexBuffers: 8, |
| }, |
| }); |
| let buffer0 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let texture0 = device0.createTexture({ |
| size: {width: 1100, height: 256, depthOrArrayLayers: 1}, |
| format: 'astc-10x8-unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let texture1 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| commandEncoder0.clearBuffer(buffer0); |
| } catch {} |
| let buffer1 = device0.createBuffer({ |
| size: 432, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let textureView0 = texture1.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6}); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| adapter0.label = '\uc623\u064b\u{1f8da}\ue1a1\u78b7\u{1fd0a}\u{1fce2}\uecf7\uf16c\u0eaa'; |
| } catch {} |
| let textureView1 = texture1.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture2 = device0.createTexture({ |
| size: [8, 8, 23], |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder0 = commandEncoder1.beginComputePass(); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise1; |
| } catch {} |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture3 = device0.createTexture({ |
| size: [24, 24, 1], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false}); |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'film', transfer: 'linear'} }); |
| let videoFrame1 = videoFrame0.clone(); |
| let buffer2 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let computePassEncoder1 = commandEncoder0.beginComputePass(); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true}); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 161, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let texture4 = device0.createTexture({ |
| size: [1310, 1, 97], |
| sampleCount: 1, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture5 = device0.createTexture({size: {width: 655}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 52, 96); |
| } catch {} |
| try { |
| commandEncoder2.copyBufferToBuffer(buffer2, 0, buffer1, 72, 4); |
| } catch {} |
| let imageData0 = new ImageData(16, 64); |
| try { |
| device0.label = '\uc4b0\u0722\u5cef\u{1fe90}\ua95b\u{1fec6}\u4022'; |
| } catch {} |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let buffer3 = device0.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let texture6 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 17}, |
| mipLevelCount: 3, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} }); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer4 = device0.createBuffer({size: 181, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView2 = texture6.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 2}); |
| let texture7 = device0.createTexture({ |
| size: {width: 327}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint'], |
| }); |
| let textureView3 = texture1.createView({baseArrayLayer: 1, arrayLayerCount: 4}); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder2.insertDebugMarker('\u7fe9'); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} }); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 72.67, |
| lodMaxClamp: 89.36, |
| }); |
| let texture8 = device0.createTexture({ |
| size: [12, 12, 20], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder2 = commandEncoder4.beginComputePass(); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| struct VertexInput1 { |
| @location(9) @interpolate(flat, centroid) location_9: vec4i, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(12) @interpolate(flat, first) location_12: f16, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput0 { |
| @location(1) @interpolate(linear) location_1: vec2h, |
| @location(2) @interpolate(flat, sample) location_2: vec2u, |
| } |
| |
| struct FragmentInput0 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentInput1 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct ComputeInput2 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| var<private> vp1: f16 = f16(13509.5); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp0 = frexp(vec2f(0.03202e29, 0.5314)); |
| |
| var<private> vp2 = modf(vec2h(12746.9, 4141.2)); |
| |
| struct FragmentOutput0 { |
| @location(0) @interpolate(flat) location_0: vec2u, |
| } |
| |
| struct ComputeInput1 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| var<workgroup> vw0: atomic<u32>; |
| |
| @group(0) @binding(20) var<storage, read> buffer5: array<array<array<vec2f, 12>, 4>>; |
| |
| struct ComputeInput3 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct T0 { |
| @align(64) f0: array<array<f16, 96>>, |
| } |
| |
| struct ComputeInput0 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| @vertex @must_use |
| fn vertex0(@builtin(instance_index) instance_index: u32, a1: VertexInput0, @location(10) location_10: vec2f, @location(15) location_15: vec2f, @location(11) @interpolate(flat) location_11: vec4u, a5: VertexInput1) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = vec4f(location_10[unconst_u32(311951331)]); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment0(@builtin(sample_mask) sample_mask: u32, a1: FragmentInput0, a2: FragmentInput1) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| vp1 = f16(a2.sample_index); |
| return out; |
| } |
| |
| /* used global variables: buffer5 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0(@builtin(local_invocation_index) local_invocation_index: u32, a1: ComputeInput0, a2: ComputeInput1, a3: ComputeInput2, @builtin(global_invocation_id) global_invocation_id: vec3u) { |
| atomicCompareExchangeWeak(&vw0, unconst_u32(816719404), unconst_u32(23416623)); |
| let ptr0: ptr<storage, vec2f, read> = &buffer5[arrayLength(&buffer5)][unconst_u32(105949802)][11]; |
| vp1 = vec4h(unpack4xU8(unconst_u32(432482517)))[0]; |
| vp0 = frexp(buffer5[unconst_i32(54318407)][3][11]); |
| _ = buffer5; |
| } |
| |
| /* used global variables: buffer5 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute1(a0: ComputeInput3, @builtin(workgroup_id) workgroup_id: vec3u) { |
| vp2 = modf(bitcast<vec2h>((*&buffer5)[unconst_u32(406864251)][unconst_u32(1101984359)][11][unconst_u32(88580481)])); |
| let vf0: u32 = arrayLength(&buffer5); |
| vp0.fract *= (*&buffer5)[unconst_u32(875457969)][3][11]; |
| vp0.fract *= unpack2x16unorm(arrayLength(&(*&buffer5))); |
| vp0 = frexp(vec2f(buffer5[arrayLength(&buffer5)][unconst_u32(67040610)][11][unconst_u32(177354676)])); |
| let ptr1: ptr<storage, array<array<vec2f, 12>, 4>, read> = &(*&buffer5)[arrayLength(&(*&buffer5))]; |
| let ptr2: ptr<storage, array<vec2f, 12>, read> = &buffer5[u32(buffer5[arrayLength(&buffer5)][unconst_u32(378042590)][11][unconst_u32(873663210)])][unconst_u32(194494671)]; |
| vp0 = frexp((*&buffer5)[arrayLength(&(*&buffer5))][3][unconst_u32(116497877)]); |
| vp1 = f16(buffer5[unconst_u32(436120072)][unconst_u32(888880376)][unconst_u32(164415751)][unconst_u32(642445733)]); |
| vp0.exp = vec2i((*&buffer5)[arrayLength(&(*&buffer5))][unconst_u32(463837102)][11].rr); |
| _ = buffer5; |
| }`, |
| }); |
| let buffer6 = device0.createBuffer({size: 132, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let texture9 = device0.createTexture({ |
| size: [655, 1, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture10 = device0.createTexture({ |
| size: [655, 1, 1], |
| mipLevelCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let texture11 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 119}, |
| mipLevelCount: 2, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture12 = device0.createTexture({ |
| size: [1310, 1, 108], |
| mipLevelCount: 8, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView4 = texture12.createView({aspect: 'all', format: 'rg8uint', baseMipLevel: 1, mipLevelCount: 1}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder0.insertDebugMarker('\u83c8'); |
| } catch {} |
| await gc(); |
| let imageBitmap0 = await createImageBitmap(videoFrame2); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let textureView5 = texture4.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let textureView6 = texture11.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1}); |
| let textureView7 = texture11.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 16}); |
| let sampler1 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.43, |
| maxAnisotropy: 16, |
| }); |
| try { |
| renderBundleEncoder0.setVertexBuffer(5, buffer6); |
| } catch {} |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| let pipelineLayout1 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1], |
| }); |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let textureView8 = texture9.createView({}); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true}); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'}); |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| commandEncoder5.copyBufferToBuffer(buffer2, 4, buffer0, 4, 4); |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 0, resource: {buffer: buffer6}}, {binding: 1, resource: {buffer: buffer6}}], |
| }); |
| let pipelineLayout2 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1], |
| }); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let texture13 = device0.createTexture({ |
| size: [1410, 78, 3], |
| mipLevelCount: 1, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView9 = texture3.createView({}); |
| let computePassEncoder3 = commandEncoder3.beginComputePass(); |
| let renderPassEncoder0 = commandEncoder5.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: -801.1, g: 455.1, b: -92.45, a: -463.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 318121429, |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 104, 5); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer6, 0); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture14 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| mipLevelCount: 2, |
| format: 'eac-rg11unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture15 = device0.createTexture({ |
| size: [1310, 1, 1], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| let sampler2 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 73.46, |
| }); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer1, 'uint32', 52, 76); |
| } catch {} |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'smpte240m'} }); |
| let textureView10 = texture13.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(1017), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(466), 42, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer1, 'uint16', 120, 35); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer6}}, {binding: 0, resource: {buffer: buffer6}}], |
| }); |
| let computePassEncoder4 = commandEncoder8.beginComputePass(); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup0, new Uint32Array(1790), 1_750, 0); |
| } catch {} |
| let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}}); |
| let pipeline1 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{ |
| format: 'rg8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 76, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x4', offset: 0, shaderLocation: 12}, |
| {format: 'float32', offset: 8, shaderLocation: 15}, |
| {format: 'uint8x4', offset: 20, shaderLocation: 2}, |
| {format: 'float16x4', offset: 28, shaderLocation: 10}, |
| {format: 'uint32', offset: 16, shaderLocation: 11}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 9}, |
| {format: 'float32x3', offset: 0, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer7 = device0.createBuffer({ |
| size: 256, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({ |
| size: [48, 48, 1], |
| mipLevelCount: 3, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture17 = device0.createTexture({ |
| size: [163], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView11 = texture9.createView({dimension: '2d'}); |
| let renderPassEncoder1 = commandEncoder6.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: -512.5, g: -316.7, b: -914.6, a: 326.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let pipeline2 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| let texture18 = device0.createTexture({ |
| size: [6, 6, 1], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView12 = texture4.createView({dimension: '2d', baseArrayLayer: 1}); |
| let renderPassEncoder2 = commandEncoder9.beginRenderPass({colorAttachments: [{view: textureView9, loadOp: 'load', storeOp: 'discard'}]}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, stencilReadOnly: true}); |
| try { |
| computePassEncoder0.setPipeline(pipeline2); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let texture19 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 26}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint'], |
| }); |
| let textureView13 = texture11.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6}); |
| let computePassEncoder5 = commandEncoder7.beginComputePass(); |
| try { |
| computePassEncoder1.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 16}, |
| aspect: 'all', |
| }, new Uint8Array(222).fill(196), /* required buffer size: 222 */ |
| {offset: 222}, {width: 321, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| let texture20 = device0.createTexture({ |
| size: [327, 1, 6], |
| mipLevelCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView14 = texture6.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer1, 'uint32', 68, 56); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 40, new DataView(new ArrayBuffer(156924)), 2873, 8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 130, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(2_137).fill(120), /* required buffer size: 2_137 */ |
| {offset: 27, bytesPerRow: 743}, {width: 390, height: 18, depthOrArrayLayers: 1}); |
| } catch {} |
| let imageData1 = new ImageData(20, 16); |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 0, resource: {buffer: buffer6}}, {binding: 1, resource: {buffer: buffer6}}], |
| }); |
| let texture21 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView15 = texture20.createView({dimension: '2d', mipLevelCount: 1}); |
| let renderPassEncoder3 = commandEncoder10.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: 953.6, g: 883.3, b: 479.2, a: 427.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.setStencilReference(28); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup2, new Uint32Array(2668), 163, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup2, new Uint32Array(1544), 437, 0); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 2, resource: textureView8}, {binding: 161, resource: externalTexture0}], |
| }); |
| let commandEncoder11 = device0.createCommandEncoder(); |
| let textureView16 = texture11.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 13}); |
| let texture22 = device0.createTexture({ |
| size: [24, 24, 1], |
| mipLevelCount: 3, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder4 = commandEncoder11.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: -583.0, g: 389.6, b: 364.8, a: -847.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 361258285, |
| }); |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(2, buffer6, 0, 8); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let computePassEncoder6 = commandEncoder2.beginComputePass(); |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(3847), 329, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 0, new DataView(new ArrayBuffer(1828)), 105, 132); |
| } catch {} |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'gamma22curve'} }); |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| struct T11 { |
| f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| override override2: i32; |
| |
| struct T5 { |
| @align(128) f0: array<atomic<u32>>, |
| } |
| |
| struct T6 { |
| f0: array<u32>, |
| } |
| |
| struct T4 { |
| @align(2) @size(58) f0: bool, |
| } |
| |
| struct T9 { |
| f0: array<u32>, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T7 { |
| @align(32) f0: array<vec4i>, |
| } |
| |
| struct T1 { |
| f0: array<atomic<i32>>, |
| } |
| |
| override override3: bool; |
| |
| struct T8 { |
| @size(176) f0: T4, |
| } |
| |
| override override1: f32; |
| |
| struct T3 { |
| @align(64) f0: array<array<array<atomic<u32>, 1>, 1>>, |
| } |
| |
| struct ComputeInput4 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| struct T2 { |
| @align(128) f0: array<array<array<atomic<i32>, 1>, 1>>, |
| } |
| |
| /* zero global variables used */ |
| fn fn1() { |
| let vf9: vec3u = select(vec3u(unconst_u32(385826229), unconst_u32(1049758089), unconst_u32(8582546)), vec3u(unconst_u32(254193972), unconst_u32(1039786940), unconst_u32(1553595942)), unconst_bool(false)); |
| let vf10: vec4i = insertBits(vec4i(unconst_i32(72970644), unconst_i32(585648035), unconst_i32(571640481), unconst_i32(311140275)), vec4i(unconst_i32(257094930), unconst_i32(129299730), unconst_i32(1723939094), unconst_i32(340978599)), unconst_u32(234324059), unconst_u32(245152213)); |
| } |
| |
| struct T12 { |
| f0: array<u32>, |
| } |
| |
| @group(0) @binding(1) var<storage, read_write> buffer9: T2; |
| |
| struct T10 { |
| f0: T4, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer8: array<array<f16, 29>>; |
| |
| /* zero global variables used */ |
| fn fn0(a0: array<array<vec2f, 1>, 4>) -> i32 { |
| var out: i32; |
| out = vec4i(unpack4x8snorm(unconst_u32(48933845)).yyxz.xzzx.ggaa.rbbg.yzyz)[1]; |
| out += bitcast<i32>(pack4xU8Clamp(reverseBits(vec4u(unconst_u32(646620594), unconst_u32(338653333), unconst_u32(677484612), unconst_u32(218541895))))); |
| out ^= bitcast<vec3i>(step(vec3f(cos(vec4h(f16(override1))).ggr), step(vec3f(unconst_f32(0.03642e-33), unconst_f32(-0.2157), unconst_f32(0.02184e-15)), vec3f(unconst_f32(0.4315), unconst_f32(0.1045), unconst_f32(-0.1076)))))[2]; |
| let vf1: vec4f = unpack4x8snorm(unconst_u32(575974109)); |
| let vf2: f32 = ldexp(unconst_f32(0.02506), unconst_i32(780964341)); |
| let vf3: u32 = pack4x8snorm(vec4f(unconst_f32(0.08096e26), unconst_f32(0.04220), unconst_f32(0.05752e5), unconst_f32(0.1662))); |
| let vf4: vec3h = cross(vec3h(unconst_f16(7400.7), unconst_f16(35036.4), unconst_f16(5061.3)), vec3h(unconst_f16(5597.6), unconst_f16(1496.5), unconst_f16(7090.1))); |
| { |
| let vf5: vec3h = cross(vec3h(unconst_f16(2574.5), unconst_f16(4831.7), unconst_f16(3465.7)), vec3h(unconst_f16(8966.7), unconst_f16(964.0), unconst_f16(19562.7))); |
| out -= out; |
| let vf6: vec2i = (vec2i(unconst_i32(332447763), unconst_i32(387112644)) << vec2u(unconst_u32(1362205167), unconst_u32(140414605))); |
| switch bitcast<vec2u>(vf6.yx.yx.gg.xx)[1] { |
| case default, 1605168793: { |
| var vf7: vec3i = reverseBits(vec3i(unconst_i32(301003227), unconst_i32(-14725), unconst_i32(-251252327))); |
| for (var it0=bitcast<u32>(vf7[dot(vec2u(unconst_u32(608443876), unconst_u32(1081809715)), vec2u(unconst_u32(757580179), unconst_u32(5073112)))]); it0<(u32((unconst_f32(0.02869e-19) == unconst_f32(0.00864e-22))) & 0xfff); it0++) { |
| out += i32(a0[3][0][1]); |
| out &= bitcast<i32>(unpack2x16snorm(unconst_u32(58952174)).x); |
| out = bitcast<vec2i>(a0[unconst_u32(254329218)][0].gr)[1]; |
| } |
| vf7 |= vec3i(i32(determinant(mat4x4h(vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(2)].xzxy.gbag.bbaa), vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(2)].zyxy), vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(2)].zxzz), vec4h(transpose(mat3x3f(unconst_f32(0.03260), unconst_f32(0.04029e-43), unconst_f32(0.08663e-23), unconst_f32(0.04008), unconst_f32(0.4077e34), unconst_f32(-0.1067e15), unconst_f32(0.01492), unconst_f32(0.00882), unconst_f32(0.1894)))[unconst_i32(1)].zyxx.wzzy))))); |
| break; |
| } |
| } |
| } |
| let vf8: vec2f = a0[unconst_u32(3095911674)][unconst_u32(1919724915)]; |
| out = bitcast<i32>(a0[unconst_u32(231457642)][unconst_u32(769525788)][unconst_u32(444755722)]); |
| return out; |
| _ = override1; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T13 { |
| f0: vec2h, |
| } |
| |
| struct T0 { |
| @align(32) f0: array<u32>, |
| } |
| |
| override override0: f16 = 4032.7; |
| |
| struct FragmentOutput1 { |
| @location(4) @interpolate(flat, centroid) location_4: vec2i, |
| @location(0) @interpolate(flat) location_0: vec4u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* used global variables: buffer9 */ |
| @fragment |
| fn fragment1() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let ptr3: ptr<storage, array<atomic<i32>, 1>, read_write> = &(*&buffer9).f0[arrayLength(&(*&buffer9).f0)][unconst_u32(502603174)]; |
| return out; |
| _ = buffer9; |
| } |
| |
| /* used global variables: buffer8 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute2(a0: ComputeInput4, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u) { |
| var vf11: vec2h = ((*&buffer8)[unconst_u32(38745630)][unconst_u32(1450638908)] / vec2h(unconst_f16(8027.3), unconst_f16(4102.3))); |
| let ptr4: ptr<storage, array<f16, 29>, read_write> = &(*&buffer8)[unconst_i32(421435266)]; |
| var vf12: vec3<bool> = !vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false)); |
| vf12 = vec3<bool>(bool((*ptr4)[unconst_u32(335644331)])); |
| buffer8[unconst_u32(4294967295)][unconst_u32(1242241640)] = (unconst_f16(3102.4) / vec2h(unconst_f16(31451.0), unconst_f16(8692.1)))[0]; |
| vf12 = vec3<bool>(bool(reverseBits(unconst_i32(308681980)))); |
| { |
| buffer8[unconst_u32(394491349)][unconst_u32(1233394499)] = f16(a0.workgroup_id[0]); |
| switch u32((*&buffer8)[arrayLength(&(*&buffer8))][unconst_u32(209750462)]) { |
| case 15709278, default { |
| var vf13: u32 = ~u32(buffer8[unconst_u32(1646656802)][28]); |
| for (var jj84=0u; jj84<31; jj84++) { buffer8[unconst_u32(389344808)][jj84] += vec3h(extractBits(vec3i(unconst_i32(-799924787), unconst_i32(16797496), unconst_i32(35349488)), unconst_u32(1238330324), u32((*&buffer8)[arrayLength(&(*&buffer8))][28])).rbr.rgg.xyy.yyy).x; } |
| _ = buffer8; |
| } |
| } |
| buffer8[unconst_u32(1015993436)][28] = f16(arrayLength(&buffer8)); |
| let vf14: vec3u = global_invocation_id; |
| _ = buffer8; |
| } |
| vf11 *= bitcast<vec2h>(pack2x16float(vec2f(unconst_f32(0.03362e35), unconst_f32(0.1061e-36)))); |
| _ = buffer8; |
| }`, |
| }); |
| let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float'], |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 80, new DataView(new ArrayBuffer(117600)), 22, 28); |
| } catch {} |
| let pipeline3 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, entryPoint: 'fragment1', targets: [{format: 'rg8uint'}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x2', offset: 564, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 628, shaderLocation: 1}, |
| {format: 'float32', offset: 76, shaderLocation: 15}, |
| ], |
| }, |
| { |
| arrayStride: 52, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x2', offset: 4, shaderLocation: 10}], |
| }, |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [{format: 'sint16x4', offset: 0, shaderLocation: 9}, {format: 'uint8x2', offset: 0, shaderLocation: 2}], |
| }, |
| { |
| arrayStride: 188, |
| stepMode: 'instance', |
| attributes: [{format: 'uint16x2', offset: 52, shaderLocation: 11}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'front'}, |
| }); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer1, 'uint32', 16, 164); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 0, new Uint32Array(5551).map((_, i) => i * 4), 3203, 0); |
| } catch {} |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| let sampler3 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 40.65, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup2, new Uint32Array(232), 23, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'bt2020_12bit'} }); |
| let texture23 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let texture24 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView17 = texture4.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 11}); |
| let computePassEncoder7 = commandEncoder13.beginComputePass(); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer1, 'uint16', 22, 67); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(906), 50, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 76, 39); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer1, 'uint16', 14, 36); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToTexture({ |
| /* bytesInLastRow: 510 widthInBlocks: 255 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 168 */ |
| offset: 168, |
| buffer: buffer7, |
| }, { |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 81, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 255, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder4.insertDebugMarker('\u9d5f'); |
| } catch {} |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteSt4281', transfer: 'bt709'} }); |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 0, resource: {buffer: buffer7}}, {binding: 1, resource: {buffer: buffer7}}], |
| }); |
| let texture25 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView18 = texture8.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 3}); |
| try { |
| computePassEncoder3.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup2, []); |
| } catch {} |
| let promise3 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let imageData2 = new ImageData(80, 8); |
| let buffer10 = device0.createBuffer({size: 164, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture26 = device0.createTexture({ |
| size: [327, 1, 68], |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView19 = texture16.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(706), 57, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer1, 168); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer1, 'uint16', 42, 21); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 60, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 146 widthInBlocks: 73 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 14 */ |
| offset: 14, |
| buffer: buffer10, |
| }, {width: 73, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer7, 4, 14); |
| } catch {} |
| let videoFrame8 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup1, new Uint32Array(823), 242, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(221), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(464, 0, 1_052_702_023); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| let buffer11 = device0.createBuffer({size: 352, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture27 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 150}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView20 = texture13.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 0}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup3, new Uint32Array(861), 140, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 44, new Float32Array(4125).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.03017)), 63, 4); |
| } catch {} |
| let texture28 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer1, 16); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer1, 'uint32', 28, 42); |
| } catch {} |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 16, new DataView(new ArrayBuffer(136)), 5, 4); |
| } catch {} |
| let texture29 = device0.createTexture({ |
| size: [6, 6, 18], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let texture30 = gpuCanvasContext0.getCurrentTexture(); |
| let renderPassEncoder5 = commandEncoder12.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: -278.3, g: 993.3, b: -766.6, a: -349.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| renderBundleEncoder3.label = '\u6734\ufdd1\u5177\u7465\uf890\u7a33\u0e3f\u9250\ud5f3\u6425'; |
| } catch {} |
| let buffer12 = device0.createBuffer({size: 84, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture31 = device0.createTexture({ |
| size: [24, 24, 75], |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 64, new Float32Array(14370).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.306)), 983, 0); |
| } catch {} |
| document.body.append(canvas0); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup1, new Uint32Array(9284), 853, 0); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let texture32 = device0.createTexture({size: [24], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView21 = texture16.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 2}); |
| let computePassEncoder8 = commandEncoder14.beginComputePass(); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(29).fill(171), /* required buffer size: 29 */ |
| {offset: 29, rowsPerImage: 12}, {width: 598, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline4 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 2, resource: textureView11}, {binding: 161, resource: externalTexture0}], |
| }); |
| let buffer13 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST}); |
| try { |
| computePassEncoder7.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| let autogeneratedBindGroupLayout1 = pipeline2.getBindGroupLayout(0); |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 161, resource: externalTexture0}, {binding: 2, resource: textureView12}], |
| }); |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let texture33 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture22, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 58, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| adapter0.label = '\u331e\u53ef\uc4d5\u{1f8a0}\u0816\u1989\u652f'; |
| } catch {} |
| try { |
| device0.label = '\uc601\uc311\u0c98\u{1f6b2}\udfac\u4eab\u05df'; |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer7, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| document.body.append(canvas0); |
| let imageData3 = new ImageData(164, 8); |
| let texture34 = device0.createTexture({ |
| size: {width: 24}, |
| dimension: '1d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| document.body.append(canvas0); |
| let textureView22 = texture34.createView({}); |
| let texture35 = device0.createTexture({ |
| size: [8, 8, 13], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder9 = commandEncoder15.beginComputePass(); |
| try { |
| renderPassEncoder2.setBlendConstant({ r: 350.8, g: 293.9, b: 93.33, a: 952.1, }); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(347, 1, 27_252_069); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 10, 19); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer7, 0); |
| } catch {} |
| let buffer14 = device0.createBuffer({ |
| size: 20, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let textureView23 = texture21.createView({label: '\u{1faba}\u0906\u{1f641}\u056b', dimension: 'cube', baseArrayLayer: 1}); |
| let renderPassEncoder6 = commandEncoder16.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -159.2, g: 595.0, b: -176.4, a: 724.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 110925521, |
| }); |
| try { |
| computePassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer2, 0, 5); |
| } catch {} |
| try { |
| computePassEncoder2.insertDebugMarker('\u0def'); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let commandEncoder17 = device0.createCommandEncoder(); |
| let textureView24 = texture27.createView({}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(1899), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(741, 1, 1_710_886_560); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer1, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer14, 'uint32', 0, 8); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup5, new Uint32Array(3366), 594, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(1, buffer2, 0, 0); |
| } catch {} |
| document.body.append(canvas0); |
| let buffer15 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let textureView25 = texture34.createView({}); |
| try { |
| renderPassEncoder5.drawIndexed(2, 1, 0, 41_897_117); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 4, new Float32Array(494).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6466)), 51, 0); |
| } catch {} |
| let pipeline5 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let texture36 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture37 = device0.createTexture({ |
| size: [6, 6, 1], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder10 = commandEncoder17.beginComputePass(); |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(605), 75, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer14, 'uint16', 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline1); |
| } catch {} |
| let autogeneratedBindGroupLayout2 = pipeline0.getBindGroupLayout(0); |
| let textureView26 = texture36.createView({baseArrayLayer: 0}); |
| let textureView27 = texture10.createView({baseMipLevel: 0}); |
| let sampler4 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(156, 1, 1_510_866_816); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer15, 'uint32', 0, 11); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 0, new Uint16Array(16739).map((_, i) => i + 8), 1164, 12); |
| } catch {} |
| await gc(); |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer6}}], |
| }); |
| let buffer16 = device0.createBuffer({size: 28, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: {width: 8}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder5.draw(7, 1, 260_209_397); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer1, 28); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer6, 0, 6); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup1, new Uint32Array(126), 26, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(7, buffer2, 0, 6); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| computePassEncoder0.pushDebugGroup('\ub8c3'); |
| } catch {} |
| let texture39 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(293, 1, 112_996_766); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 16, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 108, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}, |
| {binding: 194, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let textureView28 = texture38.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer15, 'uint32', 0, 0); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Float16Array(4455).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.090)), 172, 0); |
| } catch {} |
| await gc(); |
| try { |
| textureView1.label = '\u013f\u2e08\u0e44'; |
| } catch {} |
| let commandEncoder21 = device0.createCommandEncoder({label: '\u{1fdd6}\u4a03\u{1fb93}\u{1fa7c}\u{1f6c1}\uddc9\u067a\u29d2\u0768\u{1f89a}'}); |
| let textureView29 = texture11.createView({label: '\u05bd\u7037', dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 29}); |
| let renderPassEncoder7 = commandEncoder12.beginRenderPass({colorAttachments: [{view: textureView15, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| commandEncoder20.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 7}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder11 = commandEncoder20.beginComputePass(); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| @group(1) @binding(5) var<storage, read> buffer19: array<f32, 4>; |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(1) @binding(134) var<storage, read_write> buffer21: array<array<f16, 43>>; |
| |
| @group(2) @binding(134) var<storage, read_write> buffer23: array<array<array<f16, 43>, 1>>; |
| |
| struct T0 { |
| @size(180) f0: vec2u, |
| } |
| |
| @group(1) @binding(9) var<storage, read_write> buffer20: array<array<array<array<f16, 1>, 1>, 1504>>; |
| |
| struct T5 { |
| @size(128) f0: T4, |
| } |
| |
| struct FragmentInput3 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| @group(0) @binding(1) var<storage, read_write> buffer18: T5; |
| |
| struct T6 { |
| f0: vec2h, |
| f1: array<atomic<u32>>, |
| } |
| |
| struct T4 { |
| @size(58) f0: atomic<i32>, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer17: array<array<array<array<array<array<f16, 29>, 1>, 1>, 1>, 1>>; |
| |
| struct T1 { |
| f0: array<atomic<u32>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct ComputeInput6 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| struct ComputeInput5 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T2 { |
| @align(64) f0: array<array<array<vec4i, 3>, 1>>, |
| } |
| |
| struct FragmentInput2 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| struct FragmentOutput2 { |
| @location(0) @interpolate(flat) location_0: vec4u, |
| @location(7) @interpolate(flat, either) location_7: vec2i, |
| } |
| |
| /* used global variables: buffer17, buffer18, buffer20 */ |
| @fragment |
| fn fragment2(a0: FragmentInput2, @builtin(position) position: vec4f, a2: FragmentInput3) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| out.location_0 <<= unpack4xU8(u32((*&buffer17)[arrayLength(&(*&buffer17))][bitcast<u32>(cosh(vec3f(unconst_f32(0.1642e-34), unconst_f32(0.02640), unconst_f32(0.01986)))[2])][0][unconst_u32(948466367)][unconst_u32(352467284)][28])); |
| let ptr5: ptr<storage, array<f16, 29>, read_write> = &buffer17[arrayLength(&buffer17)][unconst_u32(315355846)][0][0][unconst_u32(980513835)]; |
| let ptr6: ptr<storage, f16, read_write> = &(*&buffer17)[arrayLength(&(*&buffer17))][0][0][unconst_u32(152782352)][0][unconst_u32(296651728)]; |
| atomicXor(&buffer18.f0.f0, unconst_i32(214379720)); |
| discard; |
| out.location_7 *= vec2i(i32((*&buffer20)[unconst_u32(1210900295)][unconst_u32(304394186)][unconst_u32(91040635)][0])); |
| let ptr7: ptr<storage, f16, read_write> = &(*&buffer17)[u32(buffer17[arrayLength(&buffer17)][unconst_u32(98590128)][unconst_u32(1668899117)][unconst_u32(1606252374)][0][28])][0][0][0][unconst_u32(783931955)][28]; |
| out.location_7 = vec2i(i32((*&buffer17)[arrayLength(&(*&buffer17))][0][u32((*&buffer17)[arrayLength(&(*&buffer17))][0][0][0][unconst_u32(960182495)][28])][0][unconst_u32(521790752)][28])); |
| return out; |
| _ = buffer17; |
| _ = buffer20; |
| _ = buffer18; |
| } |
| |
| /* used global variables: buffer17, buffer19, buffer21, buffer23 */ |
| @compute @workgroup_size(2, 1, 3) |
| fn compute3(a0: ComputeInput5, @builtin(num_workgroups) num_workgroups: vec3u, a2: ComputeInput6) { |
| if bool(buffer17[arrayLength(&buffer17)][0][0][0][unconst_u32(172124662)][28]) { |
| for (var ii31=0u; ii31<0x1000; ii31+=0x11) { buffer21[ii31][unconst_u32(1671194573)] += (*&buffer17)[arrayLength(&(*&buffer17))][0][0][u32(buffer23[arrayLength(&buffer23)][unconst_u32(198959512)][42])][unconst_u32(978659652)][unconst_u32(411242398)]; } |
| buffer21[unconst_u32(1354530929)][42] *= (*&buffer17)[arrayLength(&(*&buffer17))][0][unconst_u32(255627641)][0][0][28]; |
| let ptr8: ptr<storage, f16, read_write> = &(*&buffer17)[unconst_u32(52313731)][unconst_u32(1748987500)][0][0][unconst_u32(309012799)][unconst_u32(437752196)]; |
| _ = buffer17; |
| _ = buffer23; |
| _ = buffer21; |
| } |
| buffer21[unconst_u32(544882257)][unconst_u32(604265770)] = buffer17[unconst_u32(233720024)][0][0][0][0][28]; |
| for (var jj87=0u; jj87<3; jj87++) { buffer17[u32(buffer17[arrayLength(&buffer17)][unconst_u32(88789492)][unconst_u32(438112116)][unconst_u32(128551247)][unconst_u32(85697975)][unconst_u32(1359434921)])][unconst_u32(135634090)][jj87][unconst_u32(538995344)][unconst_u32(760761537)][unconst_u32(163428371)] = (*&buffer17)[arrayLength(&(*&buffer17))][unconst_u32(11743473)][unconst_u32(175754256)][unconst_u32(126556569)][0][28]; } |
| let ptr9: ptr<storage, array<f16, 29>, read_write> = &buffer17[arrayLength(&buffer17)][0][unconst_u32(661666232)][0][0]; |
| for (var ii78=0u; ii78<0x1000; ii78+=0x11) { buffer23[ii78][unconst_u32(645245315)][unconst_u32(750405639)] = (*&buffer21)[arrayLength(&(*&buffer21))][42]; } |
| buffer21[unconst_u32(823664580)][unconst_u32(881768182)] -= (*&buffer17)[arrayLength(&(*&buffer17))][0][u32((*&buffer23)[unconst_u32(1332218338)][0][42])][0][unconst_u32(463001209)][unconst_u32(914638428)]; |
| let ptr10: ptr<storage, f16, read_write> = &(*&buffer17)[arrayLength(&(*&buffer17))][unconst_u32(748378838)][0][unconst_u32(730341544)][0][28]; |
| let ptr11: ptr<storage, f16, read_write> = &(*&buffer17)[unconst_u32(1584405990)][unconst_u32(61423881)][0][bitcast<u32>((*&buffer19)[3])][0][28]; |
| let ptr12: ptr<storage, array<array<array<array<array<array<f16, 29>, 1>, 1>, 1>, 1>>, read_write> = &(*&buffer17); |
| _ = buffer21; |
| _ = buffer23; |
| _ = buffer17; |
| _ = buffer19; |
| }`, |
| }); |
| let buffer24 = device0.createBuffer({ |
| size: 39, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 257}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup7, new Uint32Array(394), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Float32Array(2576).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.9649)), 93, 0); |
| } catch {} |
| let renderPassEncoder8 = commandEncoder21.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView24, |
| depthSlice: 33, |
| clearValue: { r: 367.8, g: 128.5, b: 601.4, a: -772.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup6, new Uint32Array(1951), 55, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(2, buffer7, 0, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData4 = new ImageData(32, 36); |
| let commandEncoder23 = device0.createCommandEncoder(); |
| try { |
| renderBundleEncoder2.setBindGroup(2, bindGroup1); |
| } catch {} |
| let buffer25 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer15, 'uint32', 0, 1); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToBuffer(buffer14, 0, buffer0, 28, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 12, new Float32Array(864).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.047)), 18, 0); |
| } catch {} |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let texture40 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder4.end(); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(7, buffer6); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let texture41 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 150}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView30 = texture12.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder12 = commandEncoder19.beginComputePass(); |
| let renderPassEncoder9 = commandEncoder11.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: -455.7, g: -57.12, b: -129.8, a: -199.5, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer15, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(3, buffer6); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 0, new Float32Array(4992).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.5147)), 489, 0); |
| } catch {} |
| let textureView31 = texture17.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup4, new Uint32Array(1194), 390, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(394, 1, 263_467_137, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer4, 100); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer1, 'uint16', 58, 22); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline3); |
| } catch {} |
| let buffer26 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder25 = device0.createCommandEncoder(); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup3); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| struct FragmentInput5 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(14) @interpolate(flat) location_14: vec2i, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexInput4 { |
| @location(10) @interpolate(linear, center) location_10: vec4h, |
| @location(5) location_5: u32, |
| @location(0) location_0: vec4h, |
| @location(4) @interpolate(flat) location_4: vec2u, |
| @location(13) @interpolate(flat, either) location_13: vec2u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct FragmentInput11 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer27: array<array<f16, 29>>; |
| |
| struct FragmentInput7 { |
| @location(9) location_9: vec4h, |
| @location(6) @interpolate(flat, either) location_6: i32, |
| } |
| |
| struct T0 { |
| @size(58) f0: array<vec2f, 3>, |
| } |
| |
| struct VertexInput3 { |
| @location(1) location_1: vec4u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(1) var<storage, read_write> buffer28: array<array<FragmentInput6, 8>>; |
| |
| struct FragmentInput6 { |
| @location(5) @interpolate(flat, center) location_5: vec4i, |
| } |
| |
| /* used global variables: buffer27 */ |
| @must_use |
| fn fn0(a0: ptr<function, vec4<bool>>) -> vec2f { |
| var out: vec2f; |
| (*a0) = vec4<bool>(cosh(vec2f(f32(arrayLength(&(*&buffer27))))).xxxy); |
| return out; |
| _ = buffer27; |
| } |
| |
| struct VertexOutput0 { |
| @location(5) @interpolate(flat) location_5: vec4i, |
| @location(9) location_9: vec4h, |
| @location(10) @interpolate(flat, first) location_10: u32, |
| @location(0) location_0: i32, |
| @location(13) location_13: vec4i, |
| @location(2) @interpolate(perspective, centroid) location_2: f32, |
| @builtin(position) position: vec4f, |
| @location(14) @interpolate(flat, center) location_14: vec2i, |
| @location(6) @interpolate(flat, either) location_6: i32, |
| @location(4) @interpolate(perspective) location_4: vec2h, |
| @location(3) @interpolate(flat, centroid) location_3: f16, |
| } |
| |
| var<workgroup> vw1: array<atomic<i32>, 1>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput2 { |
| @location(15) location_15: f32, |
| @location(3) location_3: f32, |
| @location(12) location_12: vec4u, |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct FragmentInput4 { |
| @location(4) @interpolate(perspective, center) location_4: vec2h, |
| } |
| |
| struct FragmentOutput4 { |
| @location(0) location_0: vec4u, |
| @location(1) @interpolate(perspective) location_1: vec2f, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp3: vec2i = vec2i(36294720, 307454328); |
| |
| struct FragmentInput10 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| struct FragmentOutput3 { |
| @location(0) @interpolate(flat) location_0: vec4u, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| struct FragmentInput8 { |
| @location(2) @interpolate(perspective, centroid) location_2: f32, |
| } |
| |
| struct FragmentInput9 { |
| @location(0) location_0: i32, |
| @location(10) @interpolate(flat, first) location_10: u32, |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| /* used global variables: buffer27, buffer28 */ |
| fn fn1(a0: ptr<storage, f16, read_write>) { |
| buffer28[unconst_u32(249433788)][unconst_u32(261174566)].location_5 &= vec4i(unpack4x8unorm(unconst_u32(980389416))); |
| (*a0) = f16(vp3[unconst_u32(667823807)]); |
| buffer28[unconst_u32(946438070)][unconst_u32(672904290)].location_5 *= (*&buffer28)[arrayLength(&(*&buffer28))][unconst_u32(276554769)].location_5; |
| let vf15: u32 = arrayLength(&buffer27); |
| let vf16: f32 = smoothstep(unconst_f32(0.06839), f32(abs(unconst_f16(-6704.5))), unconst_f32(0.00547)); |
| (*a0) = (*&buffer27)[arrayLength(&(*&buffer27))][28]; |
| var vf17: vec2f = unpack2x16snorm(unconst_u32(803549340)); |
| _ = buffer27; |
| _ = buffer28; |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex1(a0: VertexInput2, @location(8) location_8: vec2f, @location(2) location_2: f32, a3: VertexInput3, a4: VertexInput4, @location(7) @interpolate(linear) location_7: vec2h) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out += vec4f(a4.location_10); |
| out -= unpack4x8unorm(pack2x16snorm(vec2f(unconst_f32(0.05219e-8), unconst_f32(-0.1229e22)))); |
| var vf18: f32 = location_8[unconst_u32(156688282)]; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex2() -> VertexOutput0 { |
| var out: VertexOutput0; |
| if any( !vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(true))) { |
| out.location_4 *= vec2h(out.location_14.xx.xx); |
| } |
| out.location_0 -= bitcast<i32>(unpack4x8unorm(unconst_u32(17138128))[0]); |
| out.location_0 = i32((unconst_i32(52265602) != unconst_i32(-956688982))); |
| let vf19: vec3f = abs(vec3f(unconst_f32(0.09461), unconst_f32(0.3318e12), unconst_f32(0.3035e11))); |
| out.position *= bitcast<vec4f>(out.location_14.xyxx.yyzw); |
| out.location_0 = i32(determinant(mat2x2h())); |
| out.location_14 = vec2i(i32(out.location_10)); |
| return out; |
| } |
| |
| /* used global variables: buffer27, buffer28 */ |
| @fragment |
| fn fragment3(a0: FragmentInput4, @location(3) location_3: f16, a2: FragmentInput5, a3: FragmentInput6, @location(13) @interpolate(flat, center) location_13: vec4i, a5: FragmentInput7, a6: FragmentInput8, a7: FragmentInput9) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| for (var it1=bitcast<u32>(a0.location_4); it1<(pack2x16unorm(asin(vec2f(unconst_f32(0.1321e0), unconst_f32(0.00694)))) & 0xfff); it1++) { |
| while bool((*&buffer27)[arrayLength(&(*&buffer27))][unconst_u32(461152616)]) { |
| while bool(cosh(vec2h(unconst_f16(8844.7), unconst_f16(447.6)))[0]) { |
| out.sample_mask *= u32(buffer27[arrayLength(&buffer27)][28]); |
| let ptr13: ptr<storage, FragmentInput6, read_write> = &buffer28[unconst_u32(194026909)][unconst_u32(2129661160)]; |
| return out; |
| _ = buffer28; |
| _ = buffer27; |
| } |
| fn1(&buffer27[arrayLength(&buffer27)][unconst_u32(202951355)]); |
| switch pack4xI8((*&buffer28)[arrayLength(&(*&buffer28))][unconst_u32(874149904)].location_5) { |
| default { |
| let vf20: u32 = pack2x16snorm(vec2f(unconst_f32(0.6401e11), unconst_f32(-0.06925))); |
| } |
| } |
| return out; |
| _ = buffer27; |
| _ = buffer28; |
| } |
| _ = buffer27; |
| _ = buffer28; |
| } |
| loop { |
| fn1(&(*&buffer27)[arrayLength(&(*&buffer27))][28]); |
| out.sample_mask &= u32(location_3); |
| out.location_0 += vec4u((*&buffer28)[arrayLength(&(*&buffer28))][7].location_5); |
| break; |
| _ = buffer27; |
| _ = buffer28; |
| } |
| out.sample_mask >>= pack4xI8Clamp(buffer28[unconst_u32(1023468921)][unconst_u32(125140198)].location_5); |
| let ptr14: ptr<storage, FragmentInput6, read_write> = &(*&buffer28)[unconst_u32(677613547)][unconst_u32(556677106)]; |
| return out; |
| _ = buffer28; |
| _ = buffer27; |
| } |
| |
| /* used global variables: buffer27, buffer28 */ |
| @fragment |
| fn fragment4(a0: FragmentInput10, a1: FragmentInput11, @builtin(front_facing) front_facing: bool) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| out.location_0 &= vec4u(u32((*&buffer27)[unconst_u32(28145043)][28])); |
| switch vec3i(min(vec3f(unconst_f32(0.07495), unconst_f32(0.1203), unconst_f32(0.07386e16)), vec3f(unconst_f32(0.00895), unconst_f32(0.1541e-26), unconst_f32(0.07495e2)))).z { |
| case 373858473, 757868269, 116729796, 523329663 { |
| let ptr15: ptr<storage, FragmentInput6, read_write> = &buffer28[arrayLength(&buffer28)][unconst_u32(869159148)]; |
| _ = buffer28; |
| } |
| case default: { |
| buffer28[unconst_u32(8608783)][unconst_u32(329166974)] = FragmentInput6(vec4i(radians(vec3f(unconst_f32(0.1526), unconst_f32(0.1388e20), unconst_f32(0.07443e-20))).ggrb)); |
| vp3 = buffer28[arrayLength(&buffer28)][7].location_5.rb; |
| out.location_0 = unpack4xU8(u32((*&buffer28)[arrayLength(&(*&buffer28))][unconst_u32(806119821)].location_5[unconst_u32(2506959909)])); |
| let ptr16: ptr<storage, array<FragmentInput6, 8>, read_write> = &(*&buffer28)[arrayLength(&(*&buffer28)) - 1]; |
| buffer28[unconst_u32(47770106)][unconst_u32(143014293)].location_5 *= (*ptr16)[unconst_u32(4162355)].location_5; |
| { |
| let ptr17: ptr<storage, array<FragmentInput6, 8>, read_write> = &(*&buffer28)[unconst_u32(913884742)]; |
| for (var it2=a0.sample_mask; it2<(bitcast<u32>((*&buffer28)[unconst_u32(824550075)][7].location_5.r) & 0xfff); it2++) { |
| buffer28[unconst_u32(2131611664)][unconst_u32(537666678)].location_5 = vec4i(i32((*&buffer27)[unconst_u32(1415733748)][28])); |
| let vf21: i32 = (*&buffer28)[arrayLength(&(*&buffer28))][7].location_5[unconst_u32(174837906)]; |
| _ = buffer28; |
| _ = buffer27; |
| } |
| vp3 -= vec2i(i32(a1.sample_index)); |
| _ = buffer27; |
| _ = buffer28; |
| } |
| _ = buffer27; |
| _ = buffer28; |
| } |
| } |
| out = FragmentOutput4(vec4u(buffer28[arrayLength(&buffer28)][u32((*&buffer27)[arrayLength(&(*&buffer27)) - 1][28])].location_5), bitcast<vec2f>(buffer28[arrayLength(&buffer28)][u32((*&buffer27)[arrayLength(&(*&buffer27)) - 1][28])].location_5.gg)); |
| out.location_1 = bitcast<vec2f>((*&buffer28)[unconst_u32(1144395396)][7].location_5.xw.rg); |
| return out; |
| _ = buffer27; |
| _ = buffer28; |
| } |
| |
| /* used global variables: buffer27 */ |
| @compute @workgroup_size(3, 1, 1) |
| fn compute4(@builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u) { |
| let ptr18: ptr<workgroup, atomic<i32>> = &(*&vw1)[unconst_u32(352273314)]; |
| buffer27[unconst_u32(50634417)][unconst_u32(123582463)] = refract(vec3h(unconst_f16(8134.3), unconst_f16(18979.2), unconst_f16(24795.5)), vec3h(unconst_f16(1632.0), unconst_f16(1110.3), unconst_f16(413.6)), unconst_f16(11810.9)).x; |
| let vf22: ptr<workgroup, array<atomic<i32>, 1>> = &vw1; |
| vp3 |= vec2i(i32((*&buffer27)[arrayLength(&(*&buffer27))][28])); |
| atomicSub(&vw1[0], i32(dot(vec2h(unconst_f16(21650.5), unconst_f16(13134.7)), vec2h(unconst_f16(9614.4), unconst_f16(14309.8))))); |
| for (var it3=pack4xU8(vec4u((vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(false)) != vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(true))))); it3<(u32((*&buffer27)[arrayLength(&(*&buffer27))][unconst_u32(2450581182)]) & 0xfff); it3++) { |
| vp3 = vec2i(bitcast<i32>(global_invocation_id[unconst_u32(114022757)])); |
| } |
| for (var jj11=0u; jj11<3; jj11++) { atomicCompareExchangeWeak(&vw1[jj11], unconst_i32(20442721), unconst_i32(33987627)); } |
| return; |
| _ = buffer27; |
| }`, |
| }); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| lodMaxClamp: 51.20, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer1, 16); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer24, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer7); |
| } catch {} |
| try { |
| commandEncoder23.resolveQuerySet(querySet0, 20, 14, buffer11, 0); |
| } catch {} |
| try { |
| computePassEncoder0.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.label = '\u358d\u{1fbff}'; |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup6, new Uint32Array(905), 222, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer1, 40); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer25, 'uint32', 4, 3); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer7); |
| } catch {} |
| let textureView32 = texture7.createView({format: 'rg8uint', mipLevelCount: 1}); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer14, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder23.clearBuffer(buffer0); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let textureView33 = texture16.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer15, 'uint32', 0, 4); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexedIndirect(buffer1, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new DataView(new Uint8Array(898).map((_, i) => i).buffer), 258, 12); |
| } catch {} |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer6}}], |
| }); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer15, 'uint16', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup6, new Uint32Array(543), 56, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer4, 84); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(2, buffer6); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let pipeline6 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule0, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE}]}, |
| vertex: {module: shaderModule3, entryPoint: 'vertex2', buffers: []}, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let buffer29 = device0.createBuffer({ |
| label: '\u{1fcd6}\u4c7e\u1930\u3ab5\u5ab8', |
| size: 680, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let textureView34 = texture5.createView({aspect: 'all'}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup3, new Uint32Array(526), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup0, new Uint32Array(2578), 1_878, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(145); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer25, 'uint32', 32); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer29, 640); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| label: '\ufb8f\u0fe9\u9e16\u0fc4\u0ac8\ub466\u6f8e\u{1fcd4}', |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 2, resource: textureView5}, {binding: 161, resource: externalTexture0}], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -494.4, g: 216.9, b: 733.9, a: 924.7, }); |
| } catch {} |
| let buffer30 = device0.createBuffer({size: 360, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer1, 8); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'pq'} }); |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 0, resource: {buffer: buffer7}}, {binding: 1, resource: {buffer: buffer30}}], |
| }); |
| let texture42 = device0.createTexture({ |
| size: [6, 6, 70], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let textureView35 = texture42.createView({dimension: '2d', baseArrayLayer: 2}); |
| let texture43 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderBundleEncoder2.drawIndexed(4, 1, 2, 201_791_132); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline1); |
| } catch {} |
| let commandBuffer0 = commandEncoder5.finish(); |
| let computePassEncoder13 = commandEncoder25.beginComputePass(); |
| let renderBundle0 = renderBundleEncoder2.finish({label: '\u{1f707}\u{1fe38}'}); |
| try { |
| computePassEncoder13.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 88, new DataView(new ArrayBuffer(33888)), 45, 0); |
| } catch {} |
| let pipeline7 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 1}, |
| fragment: { |
| module: shaderModule2, |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'float32x3', offset: 104, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 720, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 156, shaderLocation: 1}, |
| {format: 'uint32x3', offset: 1076, shaderLocation: 2}, |
| {format: 'uint32x3', offset: 352, shaderLocation: 11}, |
| {format: 'sint8x4', offset: 864, shaderLocation: 9}, |
| {format: 'float32x2', offset: 52, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| document.body.prepend(canvas0); |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let texture44 = device0.createTexture({ |
| size: {width: 24}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer29); |
| } catch {} |
| try { |
| commandEncoder26.clearBuffer(buffer3); |
| } catch {} |
| let textureView36 = texture36.createView({aspect: 'all', format: 'rgba8uint'}); |
| let texture45 = device0.createTexture({size: [655, 1, 33], mipLevelCount: 5, format: 'rg8uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView37 = texture16.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderPassEncoder10 = commandEncoder26.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: -112.3, g: 82.89, b: -247.8, a: 564.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup4, new Uint32Array(1529), 31, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(3, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline6); |
| } catch {} |
| document.body.append(canvas0); |
| let img0 = await imageWithData(77, 76, '#10101010', '#20202020'); |
| let autogeneratedBindGroupLayout3 = pipeline3.getBindGroupLayout(0); |
| let bindGroup11 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 1, resource: {buffer: buffer6, offset: 0}}], |
| }); |
| let texture46 = device0.createTexture({ |
| size: {width: 1310}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture47 = device0.createTexture({ |
| size: [12, 12, 37], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView38 = texture19.createView({format: 'rg8uint', mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup8, new Uint32Array(4695), 204, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.draw(263, 21, 1_232_531_802, 554_167_373); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer15, 'uint32', 0, 1); |
| } catch {} |
| let computePassEncoder14 = commandEncoder24.beginComputePass(); |
| let sampler6 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'less', |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer24, 'uint16', 4, 7); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndirect(buffer15, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let renderPassEncoder11 = commandEncoder22.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: 14.32, g: -44.10, b: -350.8, a: -884.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer25, 'uint32', 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 0, resource: {buffer: buffer7, offset: 0}}, {binding: 1, resource: {buffer: buffer6}}], |
| }); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let textureView39 = texture11.createView({dimension: 'cube-array', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 6}); |
| try { |
| computePassEncoder2.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderBundleEncoder13.draw(159, 230, 70_471_643, 1_688_669_647); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(5, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder9.insertDebugMarker('\u2bc3'); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup9, new Uint32Array(447), 99, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline6); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 0, new Uint32Array(7765).map((_, i) => i * 8), 1113, 0); |
| } catch {} |
| let textureView40 = texture18.createView({dimension: '2d-array', aspect: 'all'}); |
| try { |
| renderPassEncoder11.beginOcclusionQuery(47); |
| } catch {} |
| try { |
| renderPassEncoder10.setStencilReference(67); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer4, 36); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndirect(buffer1, 16); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer25, 'uint16', 10, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(103).fill(95), /* required buffer size: 103 */ |
| {offset: 103}, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let renderPassEncoder12 = commandEncoder27.beginRenderPass({ |
| colorAttachments: [{view: textureView38, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet0, |
| }); |
| let renderBundle1 = renderBundleEncoder7.finish({}); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup1, new Uint32Array(3796), 2_794, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.draw(29, 15, 34_132_724, 333_101_218); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer1, 188); |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 35, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 123, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 241, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 274, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 353, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 493, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 1, resource: {buffer: buffer6, offset: 0}}, {binding: 0, resource: {buffer: buffer12}}], |
| }); |
| let commandEncoder31 = device0.createCommandEncoder(); |
| let texture48 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 41}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView41 = texture4.createView({baseArrayLayer: 2, arrayLayerCount: 4}); |
| let sampler7 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'clamp-to-edge', lodMaxClamp: 94.09}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup11, new Uint32Array(6282), 1_595, 0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer29, 8, 72); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(7, buffer29); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToTexture({ |
| /* bytesInLastRow: 146 widthInBlocks: 73 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 386 */ |
| offset: 386, |
| buffer: buffer1, |
| }, { |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 212, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 73, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 52, new DataView(new ArrayBuffer(55592)), 787, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer4, 12); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture49 = device0.createTexture({ |
| size: {width: 1310}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder15 = commandEncoder28.beginComputePass(); |
| let renderPassEncoder13 = commandEncoder18.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: 954.0, g: 131.2, b: -260.0, a: -552.2, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 142054651, |
| }); |
| try { |
| computePassEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder11.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer1, 'uint32', 128, 123); |
| } catch {} |
| try { |
| renderBundleEncoder8.pushDebugGroup('\u0bfd'); |
| } catch {} |
| try { |
| renderBundleEncoder8.popDebugGroup(); |
| } catch {} |
| try { |
| commandEncoder30.insertDebugMarker('\u0357'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Float32Array(1163).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.121)), 15, 0); |
| } catch {} |
| let renderBundle2 = renderBundleEncoder13.finish({}); |
| try { |
| computePassEncoder15.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 28, new Float32Array(3563).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.141)), 1612, 4); |
| } catch {} |
| document.body.append(img0); |
| try { |
| adapter0.label = '\u62e5\u071b\u{1f82a}\u3168\u{1f613}\udd86\u{1fb9a}\u77e2'; |
| } catch {} |
| let buffer31 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false}); |
| let commandEncoder32 = device0.createCommandEncoder(); |
| let texture50 = device0.createTexture({ |
| size: {width: 655}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder14 = commandEncoder30.beginRenderPass({colorAttachments: [{view: textureView15, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline1); |
| } catch {} |
| let buffer32 = device0.createBuffer({size: 123, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let computePassEncoder16 = commandEncoder32.beginComputePass(); |
| let renderPassEncoder15 = commandEncoder29.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -732.2, g: 84.74, b: 383.1, a: 253.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 208565681, |
| }); |
| try { |
| commandEncoder23.pushDebugGroup('\u7bef'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new Float64Array(8356).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/8355)), 4452, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData5 = new ImageData(20, 136); |
| let texture51 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 18}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder16 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: 641.9, g: 533.1, b: -536.6, a: -361.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 126310244, |
| }); |
| try { |
| computePassEncoder16.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1538), 27, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer24, 'uint16', 2, 2); |
| } catch {} |
| let pipeline8 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex1', |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x2', offset: 0, shaderLocation: 1}, |
| {format: 'float16x2', offset: 0, shaderLocation: 7}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 5}, |
| {format: 'uint32', offset: 0, shaderLocation: 4}, |
| {format: 'float32', offset: 0, shaderLocation: 15}, |
| {format: 'float32', offset: 0, shaderLocation: 2}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 13}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| document.body.append(canvas0); |
| try { |
| commandEncoder25.label = '\u167c\u{1f95b}'; |
| } catch {} |
| let buffer33 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC}); |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let renderPassEncoder17 = commandEncoder33.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: -944.3, g: 199.3, b: -965.8, a: 567.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup6, new Uint32Array(2521), 59, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 40, new DataView(new ArrayBuffer(68396)), 5337, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout4 = pipeline5.getBindGroupLayout(0); |
| let buffer34 = device0.createBuffer({size: 320, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let texture52 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup4, new Uint32Array(609), 436, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle0, renderBundle1, renderBundle1, renderBundle1, renderBundle2, renderBundle0, renderBundle1, renderBundle1, renderBundle2, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(4156), 1_596, 0); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 49, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture43, |
| mipLevel: 1, |
| origin: {x: 103, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 100, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer6, 0, 39); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new Float32Array(12855).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4499)), 2350, 0); |
| } catch {} |
| let img1 = await imageWithData(34, 24, '#10101010', '#20202020'); |
| let textureView42 = texture1.createView({dimension: '2d', baseArrayLayer: 4}); |
| let sampler8 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 88.58, |
| }); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup4); |
| } catch {} |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| renderPassEncoder8.executeBundles([renderBundle2, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer29); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer4, 28); |
| } catch {} |
| try { |
| renderBundleEncoder15.insertDebugMarker('\u06cc'); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(246, 48); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let renderBundle3 = renderBundleEncoder6.finish({}); |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder10.setVertexBuffer(0, buffer7, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 4, new Uint32Array(118).map((_, i) => i * 1), 6, 8); |
| } catch {} |
| let commandEncoder37 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup12, new Uint32Array(1902), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup3, new Uint32Array(2417), 30, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.drawIndirect(buffer15, 0); |
| } catch {} |
| let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu'); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let renderBundle4 = renderBundleEncoder10.finish({}); |
| try { |
| renderPassEncoder17.setVertexBuffer(4, buffer6, 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(6, buffer6, 36, 30); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let buffer35 = device0.createBuffer({size: 36, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder38 = device0.createCommandEncoder({}); |
| let texture53 = device0.createTexture({size: {width: 327}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0); |
| } catch {} |
| let commandEncoder39 = device0.createCommandEncoder(); |
| let textureView43 = texture43.createView({format: 'rg8uint', mipLevelCount: 1}); |
| let computePassEncoder17 = commandEncoder35.beginComputePass(); |
| try { |
| renderBundleEncoder11.setPipeline(pipeline6); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder11.draw(429, 286, 292_532_668, 970_501_414); |
| } catch {} |
| try { |
| commandEncoder23.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 16, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 108, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}, |
| {binding: 194, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let buffer36 = device0.createBuffer({size: 360, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let textureView44 = texture36.createView({}); |
| let texture54 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView45 = texture32.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer25, 'uint32', 4, 5); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup9, new Uint32Array(2052), 564, 0); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup3, new Uint32Array(3085), 3_081, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| commandEncoder34.clearBuffer(buffer3); |
| } catch {} |
| try { |
| commandEncoder36.resolveQuerySet(querySet0, 11, 7, buffer0, 0); |
| } catch {} |
| let imageData6 = new ImageData(108, 196); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder17.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup6, new Uint32Array(1168), 170, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(5, buffer7, 4); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup7, new Uint32Array(277), 27, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer1, 'uint16', 22, 35); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(2, buffer35, 0, 17); |
| } catch {} |
| try { |
| commandEncoder34.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 432 */ |
| offset: 432, |
| rowsPerImage: 129, |
| buffer: buffer1, |
| }, { |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let buffer37 = device0.createBuffer({size: 262, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer24, 'uint16', 0, 6); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(5, buffer29, 48, 19); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(1, buffer7); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Uint32Array(10562).map((_, i) => i * 3), 352, 0); |
| } catch {} |
| let pipeline9 = await promise3; |
| let buffer38 = device0.createBuffer({size: 128, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let textureView46 = texture35.createView({ |
| dimension: 'cube', |
| format: 'rg8uint', |
| baseMipLevel: 0, |
| mipLevelCount: 1, |
| baseArrayLayer: 2, |
| arrayLayerCount: 6, |
| }); |
| let renderPassEncoder18 = commandEncoder37.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: 712.3, g: 561.9, b: 361.7, a: 912.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup9, new Uint32Array(1607), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup2, new Uint32Array(1497), 293, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.draw(87, 180, 1_601_871_674, 66_307_207); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndirect(buffer4, 12); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer1, 'uint32', 0, 31); |
| } catch {} |
| let buffer39 = device0.createBuffer({ |
| size: 532, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let sampler9 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 95.61}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup9, new Uint32Array(3172), 643, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer30, 'uint16', 50, 21); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup8, new Uint32Array(1506), 288, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.draw(127, 62, 916_360_108, 1_073_916_398); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndexedIndirect(buffer4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 0, resource: {buffer: buffer12}}]}); |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let texture55 = device0.createTexture({ |
| size: [12, 12, 1], |
| mipLevelCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture56 = device0.createTexture({size: [1310, 1, 5], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer39, 'uint32', 120, 10); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndexedIndirect(buffer4, 104); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline7); |
| } catch {} |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let textureView47 = texture55.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: false}); |
| let renderBundle5 = renderBundleEncoder11.finish({}); |
| try { |
| computePassEncoder13.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup1, new Uint32Array(3166), 1_057, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 0, new Float16Array(166).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.3051)), 29, 0); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(img0); |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 0, resource: {buffer: buffer7}}, {binding: 1, resource: {buffer: buffer38}}], |
| }); |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let textureView48 = texture8.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 7}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer6, 0, 43); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup4); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| {binding: 1, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 141, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 168, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer25, 'uint16', 2, 4); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder34.clearBuffer(buffer0, 8, 16); |
| } catch {} |
| try { |
| device0.queue.label = '\u{1f968}\u066a\ue5d2\u498f\u819d'; |
| } catch {} |
| let buffer40 = device0.createBuffer({size: 304, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let textureView49 = texture11.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 19}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderPassEncoder6.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer24, 'uint32', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer29, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'}); |
| } catch {} |
| let pipeline10 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| try { |
| await promise4; |
| } catch {} |
| try { |
| renderPassEncoder10.insertDebugMarker('\u{1fe5d}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 44, new Float32Array(8582).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.481)), 2266, 0); |
| } catch {} |
| await gc(); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let texture57 = device0.createTexture({ |
| size: [48, 48, 1], |
| sampleCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView50 = texture35.createView({dimension: 'cube', mipLevelCount: 1}); |
| let renderPassEncoder19 = commandEncoder36.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: -65.76, g: -178.7, b: 162.4, a: -147.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder18.setPipeline(pipeline7); |
| } catch {} |
| let commandEncoder47 = device0.createCommandEncoder(); |
| let computePassEncoder18 = commandEncoder46.beginComputePass(); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup11, new Uint32Array(10000), 763, 0); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer15, 'uint16', 2, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer29, 0, 54); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 96, new Float64Array(8096).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/8093)), 307, 0); |
| } catch {} |
| let buffer41 = device0.createBuffer({size: 4, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder48 = device0.createCommandEncoder(); |
| let textureView51 = texture18.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup2, new Uint32Array(1022), 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer24, 'uint16', 0, 3); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer41); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 232, new Float32Array(10470).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7847)), 30, 4); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 1, resource: {buffer: buffer7, offset: 0}}, |
| {binding: 0, resource: {buffer: buffer37, size: 76}}, |
| ], |
| }); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder9.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(7, buffer2, 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.drawIndirect(buffer4, 0); |
| } catch {} |
| let buffer42 = device0.createBuffer({size: 72, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder9.draw(65, 2, 649_212_914); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(4, buffer41, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(5_981).fill(188), /* required buffer size: 5_981 */ |
| {offset: 179, bytesPerRow: 58, rowsPerImage: 50}, {width: 1, height: 1, depthOrArrayLayers: 3}); |
| } catch {} |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| let textureView52 = texture42.createView({ |
| label: '\u219d\u{1fb1a}\u02fa\u2099\uf989\u07ae\u0ba0\uc579\u25c2\u{1fcd5}\ue958', |
| dimension: '2d', |
| baseArrayLayer: 1, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup4, new Uint32Array(2708), 840, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup6, new Uint32Array(1275), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(37, 1, 1_395_886_478); |
| } catch {} |
| try { |
| await buffer10.mapAsync(GPUMapMode.READ, 24, 32); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 4, new BigInt64Array(1113).map((_, i) => BigInt(i - 10)), 10, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 2, y: 6, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(120_282).fill(248), /* required buffer size: 120_282 */ |
| {offset: 240, bytesPerRow: 162, rowsPerImage: 82}, {width: 0, height: 4, depthOrArrayLayers: 10}); |
| } catch {} |
| let pipeline11 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x4deb80e}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment2', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'unorm8x2', offset: 0, shaderLocation: 12}, |
| {format: 'uint32', offset: 0, shaderLocation: 2}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 1}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 11}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 15}, |
| ], |
| }, |
| {arrayStride: 4, stepMode: 'instance', attributes: [{format: 'sint8x4', offset: 0, shaderLocation: 9}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| await gc(); |
| try { |
| globalThis.someLabel = externalTexture2.label; |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 493, resource: textureView35}, |
| {binding: 274, resource: externalTexture1}, |
| {binding: 35, resource: sampler9}, |
| {binding: 123, resource: textureView8}, |
| {binding: 353, resource: textureView20}, |
| {binding: 241, resource: textureView42}, |
| ], |
| }); |
| let buffer43 = device0.createBuffer({ |
| size: 132, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture58 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 76}, |
| mipLevelCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder20 = commandEncoder41.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: 860.7, g: -588.5, b: 263.4, a: -305.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup17, new Uint32Array(1859), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer42, 8); |
| } catch {} |
| try { |
| renderBundleEncoder9.draw(202, 0, 1_322_821_113); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'pq'} }); |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(57, 3, 310_520_415); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(2, 1, 0, -1_534_996_898, 1); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer40, 8); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder9.draw(242, 0, 1_221_547_938, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.drawIndirect(buffer42, 0); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| commandEncoder45.resolveQuerySet(querySet0, 23, 3, buffer26, 0); |
| } catch {} |
| try { |
| commandEncoder34.insertDebugMarker('\u{1f6ae}'); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup8, new Uint32Array(285), 54, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder14.setStencilReference(959); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(8, 1, 44_709_480, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline8); |
| } catch {} |
| let pipeline12 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'unorm8x2', offset: 270, shaderLocation: 15}, |
| {format: 'uint32x3', offset: 184, shaderLocation: 2}, |
| {format: 'sint16x4', offset: 184, shaderLocation: 9}, |
| {format: 'float32x3', offset: 64, shaderLocation: 10}, |
| {format: 'uint16x4', offset: 484, shaderLocation: 11}, |
| ], |
| }, |
| { |
| arrayStride: 28, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32', offset: 0, shaderLocation: 1}, |
| {format: 'float16x2', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let autogeneratedBindGroupLayout5 = pipeline0.getBindGroupLayout(0); |
| let bindGroup18 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 16, resource: externalTexture0}, |
| {binding: 2, resource: textureView2}, |
| {binding: 194, resource: externalTexture3}, |
| {binding: 0, resource: {buffer: buffer34}}, |
| {binding: 108, resource: sampler2}, |
| ], |
| }); |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| let sampler10 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 97.56, |
| compare: 'greater', |
| }); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true}); |
| let sampler11 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 97.36, |
| compare: 'greater', |
| }); |
| try { |
| renderPassEncoder9.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder8.setStencilReference(1382); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(1, buffer2, 4, 2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup3, new Uint32Array(3649), 1_508, 0); |
| } catch {} |
| try { |
| commandEncoder40.resolveQuerySet(querySet0, 13, 3, buffer43, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 4, new Uint32Array(23933).map((_, i) => i * 8), 2319, 0); |
| } catch {} |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let textureView53 = texture11.createView({dimension: '2d-array', format: 'rg32sint', mipLevelCount: 1, arrayLayerCount: 7}); |
| try { |
| computePassEncoder11.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer39, 92); |
| } catch {} |
| try { |
| renderBundleEncoder9.drawIndirect(buffer40, 20); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline8); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer37, size: 68}}], |
| }); |
| let texture59 = device0.createTexture({ |
| size: [163, 1, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture60 = device0.createTexture({ |
| size: [163, 1, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView54 = texture23.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(0, buffer40); |
| } catch {} |
| let textureView55 = texture39.createView({ |
| label: '\u{1fdb0}\ubdd7\u9f1b\u{1f71d}\u04d9\u2900\u976d\u0fda\ua35f\uae71', |
| dimension: '2d-array', |
| baseArrayLayer: 0, |
| }); |
| let texture61 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 47}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer39, 72, 81); |
| } catch {} |
| let imageData7 = new ImageData(64, 124); |
| let textureView56 = texture50.createView({baseArrayLayer: 0}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer39, 'uint16', 190, 124); |
| } catch {} |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup14, new Uint32Array(2285), 311, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup8, new Uint32Array(201), 19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer40, 92); |
| } catch {} |
| let img2 = await imageWithData(28, 2, '#10101010', '#20202020'); |
| let autogeneratedBindGroupLayout6 = pipeline0.getBindGroupLayout(0); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder12.setPipeline(pipeline8); |
| } catch {} |
| let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute1', constants: {}}}); |
| let videoFrame11 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let buffer44 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let textureView57 = texture0.createView({mipLevelCount: 1}); |
| let textureView58 = texture60.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle0, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(5, buffer40); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline12); |
| } catch {} |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer2, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(314, 142); |
| let textureView59 = texture16.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer1, 176); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(213, 51, 31_972_708, 372_284_704); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(3, buffer35, 0, 6); |
| } catch {} |
| try { |
| commandEncoder39.copyBufferToBuffer(buffer33, 0, buffer44, 4, 0); |
| } catch {} |
| let texture62 = device0.createTexture({size: [12, 12, 1], sampleCount: 1, format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC}); |
| let texture63 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView60 = texture29.createView({}); |
| try { |
| renderPassEncoder7.drawIndirect(buffer40, 32); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(73, 284, 1_548_824_834, 622_500_503); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| await gc(); |
| try { |
| globalThis.someLabel = texture56.label; |
| } catch {} |
| let buffer45 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture64 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 4}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let renderBundle6 = renderBundleEncoder3.finish({}); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| renderPassEncoder11.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let promise5 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let buffer46 = device0.createBuffer({size: 292, usage: GPUBufferUsage.UNIFORM}); |
| let texture65 = device0.createTexture({ |
| size: [8, 8, 13], |
| dimension: '2d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView61 = texture48.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder7.drawIndexed(1, 0, 0, 360_282_584); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| commandEncoder11.clearBuffer(buffer1); |
| } catch {} |
| try { |
| renderBundleEncoder4.insertDebugMarker('\u849f'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 24, new BigInt64Array(3630).map((_, i) => BigInt(i - 0)), 451, 24); |
| } catch {} |
| let bindGroup20 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 0, resource: {buffer: buffer32, size: 68}}], |
| }); |
| let texture66 = device0.createTexture({ |
| size: [8, 8, 479], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder11.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup20, new Uint32Array(1335), 79, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 84, new Float32Array(27679).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.518)), 31, 36); |
| } catch {} |
| try { |
| offscreenCanvas1.getContext('webgl2'); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 87, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 302, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup21 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer30}}, {binding: 0, resource: {buffer: buffer12}}], |
| }); |
| let buffer47 = device0.createBuffer({ |
| size: 44, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup17, new Uint32Array(454), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(82, 0, 1_613_129_233); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup18, new Uint32Array(907), 109, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder12.pushDebugGroup('\u{1fa52}'); |
| } catch {} |
| try { |
| computePassEncoder12.popDebugGroup(); |
| } catch {} |
| try { |
| computePassEncoder8.insertDebugMarker('\u{1f852}'); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let buffer48 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder54 = device0.createCommandEncoder({label: '\u4ce7\ua8d3\u038f\u{1ff64}\u2bc1\u0385\uf9ef'}); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({ |
| label: '\u1ace\u3252\u13d4\u0121\u219f\u4aa0\u{1fadd}\u92c3', |
| colorFormats: ['rg8uint'], |
| stencilReadOnly: true, |
| }); |
| try { |
| renderPassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(171); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer14, 'uint16', 0, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| let arrayBuffer0 = buffer10.getMappedRange(24, 0); |
| document.body.append(canvas1); |
| await gc(); |
| let textureView62 = texture23.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer45, 0, 40); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer49 = device0.createBuffer({size: 488, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let texture67 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| await gc(); |
| let imageData8 = new ImageData(8, 4); |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 20, resource: {buffer: buffer49}}, |
| {binding: 2, resource: textureView29}, |
| {binding: 0, resource: textureView57}, |
| {binding: 9, resource: externalTexture0}, |
| ], |
| }); |
| let texture68 = device0.createTexture({ |
| label: '\u{1f799}\u0b51\u54a0\ufef2\u0083\u0170\u{1ff8a}', |
| size: [163, 1, 1], |
| mipLevelCount: 3, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView63 = texture38.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup10, []); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(6, buffer40); |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 241, resource: textureView42}, |
| {binding: 123, resource: textureView20}, |
| {binding: 493, resource: textureView52}, |
| {binding: 274, resource: externalTexture0}, |
| {binding: 353, resource: textureView57}, |
| {binding: 35, resource: sampler3}, |
| ], |
| }); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup13, new Uint32Array(1104), 53, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| document.body.prepend(img2); |
| let texture69 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture70 = device0.createTexture({ |
| size: [327], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup13, new Uint32Array(2861), 136, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline6); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let textureView64 = texture38.createView({arrayLayerCount: 1}); |
| let textureView65 = texture58.createView({dimension: '2d', format: 'rg8uint', baseArrayLayer: 6}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(0, buffer6, 28, 2); |
| } catch {} |
| let texture71 = device0.createTexture({ |
| size: [24, 24, 12], |
| mipLevelCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView66 = texture26.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 17}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| textureView41.label = '\u7e00\u4489\u0021\u0e96\ud194\u9166'; |
| } catch {} |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let texture72 = device0.createTexture({ |
| size: [6, 6, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture73 = device0.createTexture({ |
| size: {width: 163}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame10, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder14.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder20.draw(225, 0, 151_228_992); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline7); |
| } catch {} |
| let arrayBuffer1 = buffer10.getMappedRange(32, 0); |
| try { |
| commandEncoder53.resolveQuerySet(querySet0, 19, 4, buffer32, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer40, 12, new DataView(new ArrayBuffer(14352)), 73, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(21).fill(251), /* required buffer size: 21 */ |
| {offset: 21, bytesPerRow: 26}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData9 = new ImageData(8, 92); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 2, resource: textureView17}, {binding: 161, resource: externalTexture1}], |
| }); |
| let texture74 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 26}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder14.drawIndirect(buffer1, 36); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer30, 'uint16', 38, 72); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(1, buffer47); |
| } catch {} |
| offscreenCanvas0.height = 13; |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| let commandBuffer1 = commandEncoder12.finish({}); |
| let texture75 = device0.createTexture({size: [1310, 1, 11], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView67 = texture71.createView({dimension: '2d', format: 'rg8uint', baseArrayLayer: 3}); |
| let sampler12 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 73.84}); |
| try { |
| computePassEncoder15.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder14.draw(14, 591, 89_200_004, 4_337_801); |
| } catch {} |
| try { |
| renderPassEncoder14.drawIndirect(buffer42, 24); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer15, 'uint32', 4, 8); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup23); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup16, new Uint32Array(487), 30, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.drawIndirect(buffer48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer47, 0, buffer25, 12, 4); |
| } catch {} |
| let img3 = await imageWithData(13, 202, '#10101010', '#20202020'); |
| let buffer50 = device0.createBuffer({size: 263, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let texture76 = device0.createTexture({size: {width: 1310}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderPassEncoder14.end(); |
| } catch {} |
| try { |
| renderBundleEncoder20.drawIndirect(buffer4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer39, 'uint16', 22, 6); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer2, 0, 0); |
| } catch {} |
| let arrayBuffer2 = buffer10.getMappedRange(40, 4); |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer33, 4, buffer3, 44, 4); |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| {binding: 1, visibility: 0, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 141, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 168, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let renderBundle7 = renderBundleEncoder20.finish(); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup15, new Uint32Array(1335), 278, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer43, 'uint16', 10, 40); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline12); |
| } catch {} |
| let arrayBuffer3 = buffer10.getMappedRange(48, 0); |
| try { |
| commandEncoder38.insertDebugMarker('\ub6f0'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Uint32Array(6745).map((_, i) => i * 3), 1131, 0); |
| } catch {} |
| let bindGroup25 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer49}}]}); |
| let buffer51 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder20.executeBundles([renderBundle3, renderBundle7, renderBundle7, renderBundle7, renderBundle3]); |
| } catch {} |
| try { |
| renderBundleEncoder18.drawIndirect(buffer40, 104); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| document.body.prepend(img1); |
| let renderBundle8 = renderBundleEncoder18.finish({}); |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer47); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer50, 184); |
| } catch {} |
| try { |
| buffer37.unmap(); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer33, 4, buffer47, 0, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer52 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder58 = device0.createCommandEncoder(); |
| let texture77 = device0.createTexture({ |
| size: [24, 24, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder8.drawIndirect(buffer15, 0); |
| } catch {} |
| let bindGroup26 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 9, resource: externalTexture5}, |
| {binding: 20, resource: {buffer: buffer49}}, |
| {binding: 0, resource: textureView20}, |
| {binding: 2, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let texture78 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup13, new Uint32Array(1784), 141, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer1, 64); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 36, new DataView(new ArrayBuffer(8448)), 122, 4); |
| } catch {} |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let texture79 = device0.createTexture({ |
| label: '\u939a\u77e6\ufc73\u06bf\ud548\u2477\u{1ff04}\u{1fab1}\u0872\u{1fed4}', |
| size: [48], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let computePassEncoder19 = commandEncoder52.beginComputePass(); |
| let sampler13 = device0.createSampler({addressModeW: 'clamp-to-edge', lodMaxClamp: 86.43}); |
| try { |
| computePassEncoder19.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle8, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer52, 'uint32', 12, 46); |
| } catch {} |
| try { |
| renderBundleEncoder8.draw(201, 0, 421_422_422); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let buffer53 = device0.createBuffer({size: 8, usage: GPUBufferUsage.INDIRECT}); |
| let texture80 = device0.createTexture({ |
| size: {width: 24, height: 24, depthOrArrayLayers: 125}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView68 = texture68.createView({format: 'rg8uint', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup24, new Uint32Array(60), 12, 0); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder(); |
| let texture81 = device0.createTexture({size: {width: 163}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST}); |
| let renderBundle9 = renderBundleEncoder8.finish({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup4, new Uint32Array(3351), 401, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer39, 0, 145); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder48.resolveQuerySet(querySet0, 53, 0, buffer2, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| globalThis.someLabel = texture71.label; |
| } catch {} |
| let commandEncoder62 = device0.createCommandEncoder(); |
| let texture82 = device0.createTexture({size: {width: 163}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC}); |
| let renderBundle10 = renderBundleEncoder9.finish({}); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer30, 'uint16', 8, 43); |
| } catch {} |
| let textureView69 = texture9.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer40); |
| } catch {} |
| offscreenCanvas0.height = 624; |
| let imageData10 = new ImageData(8, 72); |
| let texture83 = device0.createTexture({ |
| size: [48, 48, 1], |
| dimension: '2d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup0, new Uint32Array(2413), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup3, new Uint32Array(305), 5, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(1, buffer47, 0); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(20) var<storage, read> buffer54: array<array<vec4i, 24>>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexInput7 { |
| @location(6) location_6: vec4f, |
| } |
| |
| struct VertexInput5 { |
| @location(0) location_0: vec4f, |
| } |
| |
| struct VertexOutput1 { |
| @location(15) @interpolate(flat, first) location_15: vec4f, |
| @location(13) location_13: vec2f, |
| @location(1) location_1: i32, |
| @builtin(position) position: vec4f, |
| @location(3) @interpolate(flat, centroid) location_3: vec2h, |
| @location(2) location_2: i32, |
| @location(10) location_10: vec2f, |
| @location(9) @interpolate(flat, centroid) location_9: vec4f, |
| @location(5) @interpolate(linear, either) location_5: f16, |
| } |
| |
| struct T0 { |
| @align(16) f0: array<u32>, |
| } |
| |
| var<workgroup> vw2: atomic<i32>; |
| |
| struct FragmentInput12 { |
| @location(3) @interpolate(flat, centroid) location_3: vec2h, |
| } |
| |
| struct FragmentOutput5 { |
| @location(5) location_5: vec4u, |
| @location(0) location_0: vec4u, |
| } |
| |
| @group(0) @binding(9) var et1: texture_external; |
| |
| @group(0) @binding(0) var tex4: texture_2d<f32>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct VertexInput8 { |
| @location(10) location_10: vec2h, |
| } |
| |
| struct VertexInput6 { |
| @location(13) location_13: vec2i, |
| @location(11) @interpolate(flat) location_11: vec2u, |
| @location(15) location_15: vec4u, |
| @location(4) location_4: vec2f, |
| } |
| |
| struct VertexInput9 { |
| @location(1) location_1: vec4h, |
| } |
| |
| /* used global variables: buffer54, et1, tex4 */ |
| @vertex |
| fn vertex3(@location(5) @interpolate(flat) location_5: vec4u, a1: VertexInput5, a2: VertexInput6, a3: VertexInput7, @location(9) @interpolate(flat, centroid) location_9: vec2f, @location(8) @interpolate(perspective, sample) location_8: vec4f, a6: VertexInput8, @location(12) @interpolate(flat, either) location_12: vec2i, a8: VertexInput9, @location(14) location_14: i32, @location(3) @interpolate(linear, first) location_3: vec2f, @location(2) location_2: f16) -> VertexOutput1 { |
| var out: VertexOutput1; |
| let ptr19: ptr<function, i32> = &out.location_2; |
| loop { |
| let ptr20: ptr<function, vec4f> = &out.location_15; |
| break; |
| } |
| var vf23: i32 = (*&buffer54)[unconst_u32(94399815)][unconst_u32(77602174)][unconst_u32(712243389)]; |
| out.location_10 *= vec2f(a2.location_4[unconst_u32(445507837)]); |
| let vf24: vec4f = a1.location_0; |
| out.position = vec4f(a8.location_1.wzyw.yywy.xwzy.raba.yzww); |
| out.position -= textureLoad(tex4, vec2i(unconst_i32(584811885), unconst_i32(103406886)), unconst_i32(959836955)); |
| out.location_1 &= vec2i(textureDimensions(et1).rr)[1]; |
| return out; |
| _ = tex4; |
| _ = et1; |
| _ = buffer54; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment5(@location(9) @interpolate(flat, first) location_9: vec4f, @location(2) @interpolate(flat) location_2: i32, @location(5) @interpolate(linear) location_5: f16, @location(10) location_10: vec2f, a4: FragmentInput12) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| let vf25: vec3f = asinh(vec3f(unconst_f32(0.04990), unconst_f32(0.04810), unconst_f32(0.1406))); |
| return out; |
| } |
| |
| /* used global variables: buffer54 */ |
| @compute @workgroup_size(1, 2, 1) |
| fn compute5(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u) { |
| let ptr21: ptr<workgroup, atomic<i32>> = &vw2; |
| var vf26: i32 = atomicExchange(&(*&vw2), unconst_i32(177160125)); |
| let ptr22: ptr<storage, vec4i, read> = &buffer54[unconst_u32(4189025527)][num_workgroups[2]]; |
| var vf27: u32 = pack4x8snorm(vec4f(unconst_f32(0.1328), unconst_f32(0.03754e-39), unconst_f32(-0.04876), unconst_f32(0.1057))); |
| var vf28: u32 = local_invocation_id[unconst_u32(430560445)]; |
| let ptr23: ptr<function, u32> = &vf27; |
| _ = buffer54; |
| }`, |
| }); |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline1); |
| } catch {} |
| let autogeneratedBindGroupLayout7 = pipeline4.getBindGroupLayout(0); |
| let bindGroup27 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer49}}]}); |
| let buffer55 = device0.createBuffer({size: 252, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(7, buffer40, 0, 49); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer24, 'uint16', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(4, buffer2, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 0, new Float32Array(7617).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8342)), 2043, 20); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(131); }; |
| } catch {} |
| document.body.prepend(canvas1); |
| let imageData11 = new ImageData(8, 52); |
| let commandEncoder63 = device0.createCommandEncoder(); |
| let textureView70 = texture21.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1}); |
| let computePassEncoder20 = commandEncoder44.beginComputePass(); |
| try { |
| computePassEncoder20.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder0.draw(40, 292, 1_172_000_293, 942_933_413); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer50, 64); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(5, buffer35, 0, 2); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(9).fill(208), /* required buffer size: 9 */ |
| {offset: 9, rowsPerImage: 21}, {width: 163, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte240m', transfer: 'gamma22curve'} }); |
| let bindGroup28 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer49}}]}); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let texture84 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| dimension: '2d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView71 = texture48.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder18.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer4, 20); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer25, 'uint16', 0, 15); |
| } catch {} |
| let pipeline14 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment2', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 140, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32x4', offset: 44, shaderLocation: 2}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint8x2', offset: 6, shaderLocation: 11}, |
| {format: 'unorm8x2', offset: 2, shaderLocation: 10}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 72, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x4', offset: 16, shaderLocation: 1}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', cullMode: 'back', unclippedDepth: false}, |
| }); |
| let buffer56 = device0.createBuffer({size: 25172, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| let texture85 = device0.createTexture({ |
| size: [6, 6, 1], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle11 = renderBundleEncoder0.finish({}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup28, new Uint32Array(4045), 340, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer24, 'uint16', 8, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Float64Array(16032).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/16027)), 6579, 0); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer49}}]}); |
| let sampler14 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 69.47, |
| }); |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup22, []); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup21, new Uint32Array(785), 453, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer14, 'uint32', 0, 2); |
| } catch {} |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let renderPassEncoder21 = commandEncoder40.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView24, |
| depthSlice: 9, |
| clearValue: { r: 530.4, g: 645.1, b: -652.6, a: 12.59, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 90082926, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer52, 'uint16', 2, 32); |
| } catch {} |
| document.body.prepend(img3); |
| let texture86 = device0.createTexture({ |
| size: {width: 12}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder16.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup18, new Uint32Array(2174), 102, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 356, new Float32Array(7657).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4404)), 461, 20); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(38); }; |
| } catch {} |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let textureView72 = texture72.createView({}); |
| try { |
| renderPassEncoder6.executeBundles([renderBundle0, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer39, 'uint16', 292, 50); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup7, new Uint32Array(486), 216, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(3, buffer55, 188); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 256 */ |
| offset: 240, |
| buffer: buffer1, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.append(canvas0); |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte432', transfer: 'hlg'} }); |
| try { |
| adapter0.label = '\u{1fe33}\u1d58\u06cc\u020d\u165b'; |
| } catch {} |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let textureView73 = texture29.createView({aspect: 'all', baseMipLevel: 0}); |
| try { |
| renderPassEncoder3.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 8, new Float32Array(13059).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.136)), 3247, 8); |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 20, resource: {buffer: buffer49}}]}); |
| let buffer57 = device0.createBuffer({size: 15, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let textureView74 = texture2.createView({}); |
| let gpuCanvasContext2 = canvas1.getContext('webgpu'); |
| offscreenCanvas1.height = 931; |
| let texture87 = device0.createTexture({ |
| size: [327, 1, 7], |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToBuffer({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2002 */ |
| offset: 2002, |
| buffer: buffer56, |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 56, new DataView(new ArrayBuffer(6362)), 938, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let texture88 = device0.createTexture({ |
| size: {width: 24}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer25, 'uint16', 8, 1); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'film', transfer: 'gamma28curve'} }); |
| let texture89 = device0.createTexture({ |
| size: [12, 12, 1], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView75 = texture67.createView({}); |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer15, 'uint32', 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let autogeneratedBindGroupLayout8 = pipeline14.getBindGroupLayout(1); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 161, resource: externalTexture5}, {binding: 2, resource: textureView8}], |
| }); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let texture90 = device0.createTexture({ |
| size: {width: 24, height: 24, depthOrArrayLayers: 2}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer1, 'uint16', 32, 11); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 250 */ |
| offset: 250, |
| bytesPerRow: 9216, |
| buffer: buffer55, |
| }, { |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 5}, |
| aspect: 'all', |
| }, {width: 2, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder20.pushDebugGroup('\uc2fe'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 264, new DataView(new ArrayBuffer(15172)), 162, 16); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 16, resource: externalTexture1}, |
| {binding: 108, resource: sampler0}, |
| {binding: 0, resource: {buffer: buffer46}}, |
| {binding: 2, resource: textureView14}, |
| {binding: 194, resource: externalTexture7}, |
| ], |
| }); |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup32, new Uint32Array(449), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline7); |
| } catch {} |
| let buffer58 = device0.createBuffer({size: 40, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView76 = texture18.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup19, []); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer15, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup1, new Uint32Array(823), 7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(1, buffer45, 0, 19); |
| } catch {} |
| try { |
| commandEncoder67.copyTextureToTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let sampler15 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 91.34, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderBundleEncoder21.setVertexBuffer(4, buffer29, 28, 119); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| let texture91 = device0.createTexture({ |
| size: {width: 163}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer52, 'uint16', 34, 2); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline11); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder10.setBlendConstant({ r: -661.5, g: 358.9, b: -843.9, a: -664.9, }); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer15, 'uint16', 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 130, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(163).fill(30), /* required buffer size: 163 */ |
| {offset: 163, bytesPerRow: 386}, {width: 180, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup26, new Uint32Array(959), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(0, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| commandEncoder49.insertDebugMarker('\u{1f8cd}'); |
| } catch {} |
| try { |
| globalThis.someLabel = textureView63.label; |
| } catch {} |
| let bindGroup33 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 20, resource: {buffer: buffer49, offset: 0}}], |
| }); |
| let texture92 = device0.createTexture({ |
| size: [327, 1, 28], |
| mipLevelCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 2, resource: textureView14}, |
| {binding: 194, resource: externalTexture3}, |
| {binding: 108, resource: sampler2}, |
| {binding: 16, resource: externalTexture3}, |
| {binding: 0, resource: {buffer: buffer34}}, |
| ], |
| }); |
| let buffer59 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup31, new Uint32Array(1770), 381, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer47, 'uint16', 6, 5); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer55, 'uint32', 4, 29); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder51.copyTextureToBuffer({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 84 */ |
| offset: 84, |
| bytesPerRow: 0, |
| rowsPerImage: 202, |
| buffer: buffer56, |
| }, {width: 0, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| try { |
| computePassEncoder20.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new Uint32Array(80).map((_, i) => i * 1), 24, 0); |
| } catch {} |
| let pipeline15 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule3, entryPoint: 'fragment4', targets: [{format: 'rg8uint'}]}, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 48, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32x4', offset: 4, shaderLocation: 9}, |
| {format: 'float16x2', offset: 4, shaderLocation: 15}, |
| {format: 'uint32', offset: 0, shaderLocation: 2}, |
| {format: 'unorm16x2', offset: 12, shaderLocation: 1}, |
| {format: 'float32x2', offset: 4, shaderLocation: 10}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 11}, |
| ], |
| }, |
| {arrayStride: 24, attributes: [{format: 'unorm16x4', offset: 0, shaderLocation: 12}]}, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'none', unclippedDepth: true}, |
| }); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer43, 'uint16', 54, 2); |
| } catch {} |
| try { |
| renderBundleEncoder24.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(6, buffer55, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture60, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer60 = device0.createBuffer({ |
| size: 572, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 384}); |
| let texture93 = device0.createTexture({ |
| size: {width: 327}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView77 = texture15.createView({}); |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 124, new DataView(new Uint8Array(3609).map((_, i) => i).buffer), 1201, 56); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let textureView78 = texture54.createView({label: '\u0bad\u01ff\u{1ffe1}\u{1ffc7}\ue0d2\u0cbe\u0b09\u61ee\u{1f9b3}'}); |
| try { |
| renderPassEncoder15.setVertexBuffer(2, buffer40); |
| } catch {} |
| try { |
| commandEncoder42.copyTextureToBuffer({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 3, y: 7, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 112 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1008 */ |
| offset: 1008, |
| bytesPerRow: 20480, |
| buffer: buffer56, |
| }, {width: 7, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 8, new Uint32Array(4077).map((_, i) => i * 9), 9, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture81, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(196).fill(172), /* required buffer size: 196 */ |
| {offset: 196, bytesPerRow: 12, rowsPerImage: 24}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture94 = device0.createTexture({ |
| size: [6, 6, 1], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup31, new Uint32Array(1417), 279, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(5, buffer55, 20, 39); |
| } catch {} |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let texture95 = device0.createTexture({size: {width: 655}, dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView79 = texture46.createView({aspect: 'all'}); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(803).fill(140), /* required buffer size: 803 */ |
| {offset: 803}, {width: 32, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(imageData0); |
| try { |
| globalThis.someLabel = externalTexture2.label; |
| } catch {} |
| let buffer61 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(161); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup16, new Uint32Array(465), 82, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder70.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 13, y: 9, z: 14}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup35 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 16, resource: externalTexture6}, |
| {binding: 108, resource: sampler15}, |
| {binding: 194, resource: externalTexture6}, |
| {binding: 0, resource: {buffer: buffer50, size: 242}}, |
| {binding: 2, resource: textureView14}, |
| ], |
| }); |
| let commandEncoder73 = device0.createCommandEncoder(); |
| let commandBuffer2 = commandEncoder11.finish(); |
| let textureView80 = texture46.createView({format: 'rgb10a2unorm', arrayLayerCount: 1}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup8, new Uint32Array(508), 122, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| adapter0.label = '\u8abd\u67a8\u3864\u0528\u{1fa9b}\u{1f6f7}'; |
| } catch {} |
| let bindGroup36 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer6}}]}); |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let texture96 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 150}, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView81 = texture61.createView({mipLevelCount: 1, arrayLayerCount: 3}); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer39, 'uint16', 4, 172); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(6, buffer57, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 60, new Uint32Array(719).map((_, i) => i * 8), 23, 36); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| document.body.append(img1); |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470m', transfer: 'bt709'} }); |
| let commandBuffer3 = commandEncoder30.finish(); |
| let textureView82 = texture96.createView({}); |
| let textureView83 = texture14.createView({mipLevelCount: 1, baseArrayLayer: 6}); |
| let renderPassEncoder22 = commandEncoder73.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView51, |
| clearValue: { r: 560.0, g: -42.65, b: -410.3, a: -276.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer25, 'uint16', 6, 12); |
| } catch {} |
| try { |
| commandEncoder66.clearBuffer(buffer37, 16, 8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Float32Array(4648).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.074)), 1533, 20); |
| } catch {} |
| let autogeneratedBindGroupLayout9 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let texture97 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 21}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let imageData12 = new ImageData(64, 40); |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let texture98 = device0.createTexture({ |
| size: [1310, 1, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture99 = device0.createTexture({ |
| size: [24], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer57, 0, 1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder47.resolveQuerySet(querySet1, 41, 15, buffer36, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2, commandBuffer3]); |
| } catch {} |
| let pipeline16 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x3', offset: 1820, shaderLocation: 10}, |
| {format: 'float32', offset: 24, shaderLocation: 1}, |
| {format: 'sint32x4', offset: 1212, shaderLocation: 9}, |
| {format: 'unorm16x4', offset: 20, shaderLocation: 15}, |
| {format: 'float32x2', offset: 56, shaderLocation: 12}, |
| ], |
| }, |
| { |
| arrayStride: 156, |
| attributes: [ |
| {format: 'uint32x4', offset: 20, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 20, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| let commandEncoder77 = device0.createCommandEncoder(); |
| let textureView84 = texture98.createView({dimension: '2d', arrayLayerCount: 1}); |
| try { |
| computePassEncoder3.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(6, buffer7, 20); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup37 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 1, resource: {buffer: buffer7}}, {binding: 0, resource: {buffer: buffer60}}], |
| }); |
| let buffer62 = device0.createBuffer({ |
| label: '\u7781\u6243\u78d9\u89a8\u0caf\u3046\u0d00\u07c9', |
| size: 320, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let texture100 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder10.executeBundles([renderBundle10, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline12); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture2.label; |
| } catch {} |
| let texture101 = device0.createTexture({ |
| size: [8, 8, 178], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture102 = device0.createTexture({ |
| size: [8, 8, 13], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView85 = texture38.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup1, new Uint32Array(2100), 53, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer40, 152, new DataView(new ArrayBuffer(12152)), 1601, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer63 = device0.createBuffer({size: 33, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let textureView86 = texture101.createView({}); |
| let textureView87 = texture87.createView({arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer55, 'uint16', 14, 15); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| await buffer59.mapAsync(GPUMapMode.WRITE, 0, 12); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let texture103 = device0.createTexture({ |
| size: {width: 12}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 2_372, new Float64Array(23519).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/23514)), 11282, 560); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 108, resource: sampler8}, |
| {binding: 194, resource: externalTexture7}, |
| {binding: 2, resource: textureView19}, |
| {binding: 0, resource: {buffer: buffer62, offset: 0}}, |
| {binding: 16, resource: externalTexture5}, |
| ], |
| }); |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| let texture104 = device0.createTexture({ |
| size: {width: 570, height: 318, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder22.setPipeline(pipeline12); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 8, new Uint32Array(2395).map((_, i) => i * 9), 161, 0); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let buffer64 = device0.createBuffer({size: 1332, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView88 = texture75.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline12); |
| } catch {} |
| let arrayBuffer4 = buffer59.getMappedRange(0, 0); |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let pipeline17 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 96, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint8x2', offset: 0, shaderLocation: 2}, |
| {format: 'float32x2', offset: 8, shaderLocation: 15}, |
| {format: 'float32', offset: 40, shaderLocation: 1}, |
| {format: 'uint32', offset: 0, shaderLocation: 11}, |
| {format: 'float32x4', offset: 0, shaderLocation: 12}, |
| {format: 'sint8x2', offset: 22, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 38, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T2 { |
| @size(128) f0: T1, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T6 { |
| @size(16) f0: atomic<u32>, |
| } |
| |
| struct T0 { |
| @align(32) @size(1920) f0: array<array<vec2<bool>, 2>, 4>, |
| @size(160) f1: array<array<array<bool, 1>, 1>, 10>, |
| } |
| |
| struct T7 { |
| f0: array<T6>, |
| } |
| |
| struct T10 { |
| @size(32) f0: vec2f, |
| @size(16) f1: array<atomic<u32>, 1>, |
| f2: array<u32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| override override5: f16; |
| |
| var<workgroup> vw4: atomic<u32>; |
| |
| @id(33369) override override8: u32; |
| |
| override override4: i32 = 137073502; |
| |
| struct FragmentOutput6 { |
| @location(0) @interpolate(flat, either) location_0: vec2u, |
| @location(2) location_2: vec4i, |
| } |
| |
| struct T1 { |
| @size(16) f0: u32, |
| } |
| |
| var<workgroup> vw5: atomic<i32>; |
| |
| struct FragmentInput13 { |
| @builtin(position) position: vec4f, |
| } |
| |
| struct T5 { |
| @align(16) @size(256) f0: T1, |
| @size(112) f1: T1, |
| } |
| |
| @id(33776) override override7: f32; |
| |
| @group(1) @binding(9) var<storage, read_write> buffer67: array<array<array<array<f16, 47>, 4>, 2>, 4>; |
| |
| struct T8 { |
| @size(128) f0: vec2<bool>, |
| } |
| |
| override override9 = -0.04137e-7; |
| |
| struct T9 { |
| @size(64) f0: vec4u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @id(9399) override override6: u32 = (38595380 % 103) + 1; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<workgroup> vw3: array<f16, 1>; |
| |
| struct T3 { |
| @size(58) f0: T1, |
| } |
| |
| struct T4 { |
| @align(32) f0: array<atomic<u32>>, |
| } |
| |
| /* used global variables: buffer67 */ |
| @fragment |
| fn fragment6(a0: FragmentInput13, @builtin(sample_mask) sample_mask: u32) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| let ptr24: ptr<storage, array<array<f16, 47>, 4>, read_write> = &buffer67[unconst_u32(13726133)][1]; |
| let ptr25: ptr<storage, array<array<f16, 47>, 4>, read_write> = &(*&buffer67)[unconst_u32(842438303)][1]; |
| return out; |
| _ = buffer67; |
| }`, |
| }); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer1, 'uint16', 96, 7); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(1, buffer51, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(3, buffer39, 0, 171); |
| } catch {} |
| try { |
| buffer47.unmap(); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'hlg'} }); |
| let buffer72 = device0.createBuffer({size: 41724, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| let textureView89 = texture7.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup30, new Uint32Array(1885), 528, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer43, 'uint32', 60, 9); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(2, bindGroup4, new Uint32Array(313), 46, 0); |
| } catch {} |
| let arrayBuffer5 = buffer59.getMappedRange(8, 0); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer60}}]}); |
| let texture105 = device0.createTexture({ |
| size: [48, 48, 150], |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer35, 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup34, new Uint32Array(57), 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline17); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| buffer61.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 24, new Uint32Array(4870).map((_, i) => i * 9), 147, 24); |
| } catch {} |
| let buffer73 = device0.createBuffer({size: 104, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let textureView90 = texture105.createView({}); |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 16, new Uint32Array(85).map((_, i) => i * 10), 5, 0); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 20, resource: {buffer: buffer49}}]}); |
| let commandEncoder81 = device0.createCommandEncoder(); |
| let textureView91 = texture105.createView({dimension: '3d'}); |
| let textureView92 = texture5.createView({aspect: 'all', baseArrayLayer: 0}); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder6.setStencilReference(1186); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer35); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup10, new Uint32Array(1382), 367, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer73.destroy(); |
| } catch {} |
| try { |
| commandEncoder66.resolveQuerySet(querySet0, 19, 14, buffer11, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let textureView93 = texture69.createView({baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup34, new Uint32Array(2581), 363, 0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup8, new Uint32Array(2243), 153, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer14, 'uint16', 6, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer52, 'uint32', 52, 8); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(3, buffer55, 0, 70); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let pipeline18 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x1e2b5d42}, |
| fragment: {module: shaderModule5, constants: {}, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA}]}, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm8x4', offset: 0, shaderLocation: 0}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 11}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 12}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 13}, |
| {format: 'float32x2', offset: 0, shaderLocation: 3}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 2}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 5}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 264, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 332, shaderLocation: 1}, |
| {format: 'unorm16x2', offset: 40, shaderLocation: 4}, |
| {format: 'uint16x2', offset: 716, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer74 = device0.createBuffer({label: '\uebec\u1f4f\u6ca0\u83a1\u00eb\ub212', size: 47, usage: GPUBufferUsage.INDEX}); |
| let textureView94 = texture101.createView({}); |
| let texture106 = device0.createTexture({ |
| size: {width: 6}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder11.executeBundles([renderBundle0, renderBundle8, renderBundle8, renderBundle8, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer45, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer55); |
| } catch {} |
| try { |
| buffer45.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Uint16Array(7132).map((_, i) => i + 3), 906, 4); |
| } catch {} |
| let imageData13 = new ImageData(20, 12); |
| let commandEncoder82 = device0.createCommandEncoder(); |
| let texture107 = device0.createTexture({ |
| size: [163, 1, 1], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer57, 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(1, buffer40); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(25); }; |
| } catch {} |
| let commandEncoder83 = device0.createCommandEncoder(); |
| let renderPassEncoder23 = commandEncoder57.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView66, |
| clearValue: { r: -138.8, g: -310.4, b: -655.1, a: 286.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder12.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(21, 0, 20, -71_628_681); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer1, 24); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer43, 'uint16', 6, 6); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let texture108 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder24 = commandEncoder65.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| depthSlice: 14, |
| clearValue: { r: 884.5, g: -518.6, b: 793.1, a: 138.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder12.drawIndexedIndirect(buffer62, 140); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer52, 4); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer47, 'uint16', 14, 2); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer39); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToTexture({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 66, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 53, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer75 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let texture109 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 24}, |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder12.executeBundles([renderBundle2, renderBundle1, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer51, 'uint32', 8, 9); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(7, 0, 5, 137_722_904); |
| } catch {} |
| try { |
| commandEncoder74.insertDebugMarker('\u06fe'); |
| } catch {} |
| document.body.prepend(img1); |
| let textureView95 = texture67.createView({}); |
| try { |
| renderPassEncoder8.beginOcclusionQuery(1); |
| } catch {} |
| try { |
| renderPassEncoder8.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline7); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 22}, |
| aspect: 'all', |
| }, new Uint8Array(91).fill(114), /* required buffer size: 91 */ |
| {offset: 91}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let textureView96 = texture11.createView({dimension: 'cube', format: 'rg32sint', mipLevelCount: 1, baseArrayLayer: 4}); |
| let computePassEncoder21 = commandEncoder34.beginComputePass(); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| computePassEncoder21.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup14, new Uint32Array(742), 382, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer14, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(5, 0, 10, 65_160_896); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer62, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 11, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(2).fill(69), /* required buffer size: 2 */ |
| {offset: 2}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'bt709'} }); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderBundleEncoder16.draw(48, 0, 1_282_109_639); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(3, 0, 19, 212_406_364); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer52, 184); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| await gc(); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer50, size: 24}}, |
| {binding: 1, resource: {buffer: buffer60, offset: 0, size: 552}}, |
| {binding: 168, resource: textureView85}, |
| {binding: 141, resource: sampler3}, |
| {binding: 0, resource: textureView26}, |
| ], |
| }); |
| try { |
| renderBundleEncoder16.drawIndexed(21, 0, 4, -2_112_279_623); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer35); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup17, new Uint32Array(569), 65, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline3); |
| } catch {} |
| let textureView97 = texture83.createView({dimension: '2d-array'}); |
| let texture110 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 32}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView98 = texture90.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer15, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup21, []); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer25, 'uint32', 8, 0); |
| } catch {} |
| try { |
| commandEncoder67.copyTextureToTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 639, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 63}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer76 = device0.createBuffer({size: 1008, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup7, new Uint32Array(173), 27, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup11, new Uint32Array(4029), 180, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(10, 0, 13, 51_152_045); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer62, 28); |
| } catch {} |
| await gc(); |
| try { |
| renderBundleEncoder19.setPipeline(pipeline6); |
| } catch {} |
| await gc(); |
| let imageData14 = new ImageData(44, 16); |
| let commandEncoder88 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer43, 'uint16', 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline6); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 76, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 286, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 332, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| try { |
| renderPassEncoder22.drawIndirect(buffer63, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer73, 'uint32', 20, 36); |
| } catch {} |
| let buffer77 = device0.createBuffer({ |
| size: 396, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let textureView99 = texture72.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let renderBundle12 = renderBundleEncoder16.finish({}); |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(69, 299, 2_592_803_054, 923_193_004); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer1, 52); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline7); |
| } catch {} |
| let buffer78 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| renderPassEncoder8.beginOcclusionQuery(239); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer48, 8); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder2.insertDebugMarker('\u09ea'); |
| } catch {} |
| let buffer79 = device0.createBuffer({size: 132, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer52, 8); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer29, 4); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| buffer53.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup42 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 20, resource: {buffer: buffer60}}]}); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder22.drawIndirect(buffer4, 24); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToBuffer(buffer39, 8, buffer3, 4, 32); |
| } catch {} |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'gamma28curve'} }); |
| let texture111 = device0.createTexture({ |
| size: [48, 48, 46], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| renderBundleEncoder5.setPipeline(pipeline18); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let textureView100 = texture104.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder22.drawIndirect(buffer48, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline7); |
| } catch {} |
| await gc(); |
| let buffer80 = device0.createBuffer({size: 36, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture112 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 37}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder25 = commandEncoder79.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView66, |
| clearValue: { r: -368.2, g: 537.7, b: -492.1, a: -507.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup3, new Uint32Array(1300), 48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline18); |
| } catch {} |
| let pipeline19 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| let texture113 = device0.createTexture({ |
| size: [8, 8, 13], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView101 = texture8.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder8.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(84, 34, 3_060_584_112, 422_780_312); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer4, 8); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer74, 'uint16', 10, 3); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let bindGroup43 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 161, resource: externalTexture9}, {binding: 2, resource: textureView17}], |
| }); |
| try { |
| renderPassEncoder22.draw(513, 401, 672_706_565, 608_961_857); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup3, new Uint32Array(1300), 366, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer52, 16); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 68, new DataView(new Uint8Array(756).map((_, i) => i).buffer), 8, 80); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 2, resource: textureView29}, |
| {binding: 9, resource: externalTexture3}, |
| {binding: 20, resource: {buffer: buffer60}}, |
| {binding: 0, resource: textureView57}, |
| ], |
| }); |
| let buffer81 = device0.createBuffer({size: 148, usage: GPUBufferUsage.STORAGE}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup30, new Uint32Array(1902), 608, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(67, 34, 497_633_447, 424_565_443); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer1, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(0, buffer77, 132, 5); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer50, 36); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndirect(buffer63, 0); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToBuffer(buffer43, 72, buffer60, 136, 4); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let textureView102 = texture29.createView({}); |
| try { |
| renderPassEncoder22.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer7, 4, 182); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 0, resource: textureView57}, |
| {binding: 9, resource: externalTexture3}, |
| {binding: 2, resource: textureView6}, |
| {binding: 20, resource: {buffer: buffer49}}, |
| ], |
| }); |
| let texture114 = device0.createTexture({ |
| size: [12], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup2, []); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer62, 16); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer74, 'uint32', 0, 14); |
| } catch {} |
| let pipeline20 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer82 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| let texture115 = device0.createTexture({ |
| size: {width: 48}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup37, new Uint32Array(632), 57, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(14, 749, 197_940_735, 1_645_414_206); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer40, 84); |
| } catch {} |
| try { |
| renderBundleEncoder1.draw(108, 2, 669_579_461, 4); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndirect(buffer4, 12); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer14, 'uint16', 4, 3); |
| } catch {} |
| try { |
| commandEncoder86.clearBuffer(buffer10); |
| } catch {} |
| let bindGroup46 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer60}}, |
| {binding: 21, resource: externalTexture12}, |
| {binding: 76, resource: textureView2}, |
| {binding: 286, resource: {buffer: buffer7}}, |
| {binding: 332, resource: {buffer: buffer49}}, |
| {binding: 1, resource: textureView90}, |
| {binding: 16, resource: {buffer: buffer32, offset: 0, size: 48}}, |
| ], |
| }); |
| let textureView103 = texture115.createView({}); |
| let texture116 = device0.createTexture({ |
| size: [655, 1, 623], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup2, new Uint32Array(1843), 160, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(227, 7, 252_468_945, 297_483_489); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer42, 4); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(7, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder1.draw(124, 5, 21_028_315, 5); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer52, 'uint32', 152, 4); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u6334'); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'iec61966-2-1'} }); |
| let buffer83 = device0.createBuffer({size: 196, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let texture117 = device0.createTexture({ |
| size: {width: 655}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture118 = device0.createTexture({ |
| size: {width: 24, height: 24, depthOrArrayLayers: 58}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder22.drawIndirect(buffer52, 96); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let buffer84 = device0.createBuffer({size: 208, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let textureView104 = texture117.createView({arrayLayerCount: 1}); |
| let textureView105 = texture6.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder22.draw(17, 151, 1_296_001_192, 1_444_720_309); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndirect(buffer82, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(48); }; |
| } catch {} |
| let textureView106 = texture5.createView({}); |
| try { |
| renderPassEncoder20.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder91.copyBufferToBuffer(buffer2, 0, buffer37, 20, 0); |
| } catch {} |
| try { |
| commandEncoder49.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 1, y: 3, z: 10}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let textureView107 = texture114.createView({aspect: 'all'}); |
| let textureView108 = texture95.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder20.drawIndexedIndirect(buffer63, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder62.resolveQuerySet(querySet1, 56, 61, buffer64, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer85 = device0.createBuffer({size: 488, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder21.setStencilReference(448); |
| } catch {} |
| try { |
| renderPassEncoder20.drawIndirect(buffer83, 28); |
| } catch {} |
| try { |
| renderBundleEncoder1.draw(5, 10, 192_227_827, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer61, 8); |
| } catch {} |
| let bindGroup47 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer79, size: 128}}, {binding: 0, resource: {buffer: buffer12}}], |
| }); |
| let texture119 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer14, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup26, []); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer52, 72); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToBuffer({ |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 102, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1608 widthInBlocks: 402 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1896 */ |
| offset: 1896, |
| bytesPerRow: 3584, |
| rowsPerImage: 843, |
| buffer: buffer56, |
| }, {width: 402, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder88.insertDebugMarker('\u08ea'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'iec61966-2-1'} }); |
| let buffer86 = device0.createBuffer({size: 12, usage: GPUBufferUsage.VERTEX}); |
| let texture120 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 33}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture121 = device0.createTexture({ |
| label: '\u51e6\u00e6\u{1fddd}', |
| size: [163, 1, 1], |
| mipLevelCount: 5, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView109 = texture22.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup13, new Uint32Array(5553), 35, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(48); |
| } catch {} |
| try { |
| renderPassEncoder20.drawIndexedIndirect(buffer52, 16); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture64, |
| mipLevel: 0, |
| origin: {x: 4, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(317).fill(220), /* required buffer size: 317 */ |
| {offset: 317}, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.append(img1); |
| let textureView110 = texture120.createView({dimension: '2d'}); |
| let texture122 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup19, new Uint32Array(238), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer76, 204); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(2, buffer35, 0); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer75, 44, buffer60, 160, 8); |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 2, resource: textureView5}, {binding: 161, resource: externalTexture2}], |
| }); |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let textureView111 = texture65.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 4}); |
| try { |
| renderPassEncoder20.draw(119, 40, 2_020_413_225, 53_699_632); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndirect(buffer63, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(0, buffer51, 24); |
| } catch {} |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt709', transfer: 'smpte240m'} }); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(257, 482, 507_695_113, 1_465_543_282); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer84, 16); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup1, []); |
| } catch {} |
| try { |
| buffer79.unmap(); |
| } catch {} |
| try { |
| commandEncoder51.clearBuffer(buffer47); |
| } catch {} |
| try { |
| commandEncoder66.resolveQuerySet(querySet1, 45, 0, buffer2, 0); |
| } catch {} |
| let commandEncoder94 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder20.end(); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(144, 95, 306_197_289, 485_225_394); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup43, new Uint32Array(80), 8, 0); |
| } catch {} |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let textureView112 = texture97.createView({dimension: '3d'}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer78, 'uint16', 4, 9); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup15); |
| } catch {} |
| let commandEncoder96 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer47, 'uint32', 8, 4); |
| } catch {} |
| try { |
| buffer76.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 1, |
| origin: {x: 13, y: 5, z: 19}, |
| aspect: 'all', |
| }, new Uint8Array(6_145).fill(241), /* required buffer size: 6_145 */ |
| {offset: 3, bytesPerRow: 14, rowsPerImage: 109}, {width: 5, height: 3, depthOrArrayLayers: 5}); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 79, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView113 = texture57.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer48, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer4, 4); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder96.insertDebugMarker('\u{1fe89}'); |
| } catch {} |
| let recycledExplicitBindGroupLayout0 = pipeline8.getBindGroupLayout(3); |
| let buffer87 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let texture123 = device0.createTexture({ |
| size: {width: 24, height: 24, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(1, bindGroup0, new Uint32Array(464), 37, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.draw(34, 5, 261_599_340); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer1, 64); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 92.23, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(175, 91, 723_122_801, 850_336_577); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer14, 'uint32', 4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup26, new Uint32Array(357), 192, 0); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise13; |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup48, new Uint32Array(380), 7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndexedIndirect(buffer61, 0); |
| } catch {} |
| try { |
| commandEncoder50.copyBufferToBuffer(buffer43, 0, buffer29, 80, 12); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(2, bindGroup8, new Uint32Array(2130), 1_004, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 19, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 29, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 161, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 433, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(304, 313, 2_447_513_192, 524_680_204); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer52, 8); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup5, new Uint32Array(3594), 220, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(296, 108, 1_064_929_283, 930_660_216); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer83, 44); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder1.draw(17, 2, 188_164_938, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.drawIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setPipeline(pipeline17); |
| } catch {} |
| let textureView114 = texture110.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5}); |
| let renderBundle13 = renderBundleEncoder1.finish(); |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup16, []); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(114, 44, 3_086_715_070, 107_714_945); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer61, 16); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(1, buffer86); |
| } catch {} |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup46, new Uint32Array(7), 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(6, 138, 1_315_408_354, 1_405_024_447); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer14, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline16); |
| } catch {} |
| try { |
| commandEncoder39.insertDebugMarker('\uaa3c'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline21 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, constants: {}, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 1}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 2}, |
| {format: 'float32', offset: 0, shaderLocation: 15}, |
| {format: 'float32', offset: 0, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| document.body.append(canvas0); |
| let texture124 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 327}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup37, new Uint32Array(1842), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(146, 1, 613_493_963, 19_320_551); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer63, 4); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer43, 'uint32', 4, 6); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder55.insertDebugMarker('\u09b6'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 148, new Float32Array(2340).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.08862)), 465, 4); |
| } catch {} |
| let texture125 = device0.createTexture({ |
| label: '\u0c61\u{1f6f2}\u0f2a\u7879\u6cd5\u{1fc3e}\u98ea\u0a40\uad89\u308e\u8245', |
| size: {width: 327}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| let texture126 = device0.createTexture({ |
| size: [48, 48, 150], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder10.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup19, []); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline12); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let buffer88 = device0.createBuffer({size: 272, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let textureView115 = texture40.createView({}); |
| try { |
| computePassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(70, 79, 63_703_371, 496_387_400); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(0, buffer41, 0); |
| } catch {} |
| try { |
| commandEncoder86.copyTextureToTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder67.insertDebugMarker('\u19bd'); |
| } catch {} |
| try { |
| renderPassEncoder10.insertDebugMarker('\u00bc'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(1) var<storage, read_write> buffer90: array<array<vec4u, 8>>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct ComputeInput7 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| override override10: f16; |
| |
| struct FragmentInput14 { |
| @builtin(front_facing) front_facing: bool, |
| @builtin(position) position: vec4f, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| override override13 = 0.2414e22; |
| |
| alias vec3b = vec3<bool>; |
| |
| @id(60922) override override12: u32; |
| |
| struct FragmentOutput7 { |
| @location(0) @interpolate(flat, centroid) location_0: vec2u, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| struct ComputeInput9 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| override override11 = 0.07308; |
| |
| @group(0) @binding(0) var<storage, read_write> buffer89: array<array<array<f16, 1>, 29>>; |
| |
| struct ComputeInput8 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| /* used global variables: buffer89, buffer90 */ |
| @fragment |
| fn fragment7(a0: FragmentInput14, @builtin(sample_index) sample_index: u32) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| let ptr26: ptr<storage, array<array<f16, 1>, 29>, read_write> = &(*&buffer89)[arrayLength(&(*&buffer89))]; |
| buffer90[unconst_u32(1559401960)][unconst_u32(63495344)] += vec4u(u32((*ptr26)[unconst_u32(1019319532)][0])); |
| let ptr27: ptr<storage, vec4u, read_write> = &(*&buffer90)[arrayLength(&(*&buffer90))][7]; |
| let ptr28: ptr<storage, array<array<f16, 1>, 29>, read_write> = &(*&buffer89)[unconst_u32(3849732097)]; |
| let ptr29: ptr<storage, array<f16, 1>, read_write> = &buffer89[arrayLength(&buffer89)][unconst_u32(589559196)]; |
| buffer89[u32((*&buffer89)[arrayLength(&(*&buffer89))][unconst_u32(1060439717)][0])][unconst_u32(326766493)][unconst_u32(154094819)] = vec4h((*&buffer90)[unconst_i32(13663218)][7])[3]; |
| let ptr30: ptr<storage, vec4u, read_write> = &(*&buffer90)[unconst_u32(189457474)][7]; |
| switch i32((*&buffer89)[unconst_u32(54679169)][28][0]) { |
| case default { |
| buffer89[unconst_u32(670204027)][bitcast<u32>(override13)][unconst_u32(153793482)] = f16(arrayLength(&buffer89)); |
| _ = override13; |
| _ = buffer89; |
| } |
| } |
| let ptr31: ptr<storage, array<array<f16, 1>, 29>, read_write> = &buffer89[unconst_u32(151772330)]; |
| buffer90[unconst_u32(733684571)][unconst_u32(406445531)] += bitcast<vec4u>((unconst_i32(-213896451) - vec4i(unconst_i32(-25451390), unconst_i32(713135815), unconst_i32(967226692), unconst_i32(-1941082271))).rrbr.ragg.wwwz.wwxz); |
| let ptr32: ptr<storage, f16, read_write> = &(*ptr28)[unconst_u32(1374001242)][unconst_u32(61310411)]; |
| return out; |
| _ = override13; |
| _ = buffer89; |
| _ = buffer90; |
| } |
| |
| /* used global variables: buffer89 */ |
| @compute @workgroup_size(1, 2, 1) |
| fn compute6(a0: ComputeInput7, a1: ComputeInput8, a2: ComputeInput9) { |
| buffer89[unconst_u32(1252158667)][unconst_u32(23924862)][unconst_u32(3066123064)] += vec3h(a2.num_workgroups.rbg)[1]; |
| _ = buffer89; |
| }`, |
| }); |
| let textureView116 = texture67.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder22.end(); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer83, 'uint16', 28, 54); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(7, buffer40, 0, 0); |
| } catch {} |
| let imageData15 = new ImageData(12, 8); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout4]}); |
| let texture127 = device0.createTexture({ |
| size: [163, 1, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| commandEncoder64.insertDebugMarker('\u0b28'); |
| } catch {} |
| offscreenCanvas1.width = 645; |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 72, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder98 = device0.createCommandEncoder(); |
| let texture128 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer47, 'uint32', 0, 4); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| await gc(); |
| let canvas2 = document.createElement('canvas'); |
| let buffer91 = device0.createBuffer({size: 744, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let texture129 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup18, new Uint32Array(1505), 118, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup28, new Uint32Array(1638), 350, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| await gc(); |
| let texture130 = device0.createTexture({ |
| size: [327, 1, 55], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg8uint'], |
| }); |
| let textureView117 = texture26.createView({baseArrayLayer: 9, arrayLayerCount: 2}); |
| let renderPassEncoder26 = commandEncoder59.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: 755.7, g: -157.3, b: 730.3, a: -951.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 225887245, |
| }); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer91, 'uint32', 16, 32); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder21.insertDebugMarker('\u{1f84a}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 16, new BigInt64Array(7643).map((_, i) => BigInt(i - 5)), 196, 0); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer92 = device0.createBuffer({size: 24, usage: GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.86, |
| maxAnisotropy: 18, |
| }); |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(1, buffer84, 0); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let buffer93 = device0.createBuffer({ |
| size: 18, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, |
| }); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let textureView118 = texture92.createView({dimension: '2d-array', baseArrayLayer: 3, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer51, 'uint16', 0, 8); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\ub2d1'); |
| } catch {} |
| let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup26, new Uint32Array(415), 96, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline1); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| let texture131 = device0.createTexture({ |
| size: [12], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer52, 'uint32', 132, 17); |
| } catch {} |
| let buffer94 = device0.createBuffer({ |
| size: 212, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder101 = device0.createCommandEncoder(); |
| let texture132 = device0.createTexture({ |
| size: [12, 12, 37], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder21.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer55, 0, 45); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 44, new Float64Array(1591).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/1587)), 73, 4); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext3 = canvas2.getContext('webgpu'); |
| try { |
| await promise17; |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 194, resource: externalTexture8}, |
| {binding: 0, resource: {buffer: buffer85, offset: 0, size: 312}}, |
| {binding: 108, resource: sampler0}, |
| {binding: 16, resource: externalTexture5}, |
| {binding: 2, resource: textureView105}, |
| ], |
| }); |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup2, new Uint32Array(185), 84, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBlendConstant({ r: 696.7, g: 255.1, b: -381.8, a: 646.5, }); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte432', transfer: 'bt709'} }); |
| let bindGroup50 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 1, resource: {buffer: buffer37, size: 148}}], |
| }); |
| let textureView119 = texture98.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup1, new Uint32Array(4966), 138, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer4, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer52, 'uint32', 108, 6); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(0, buffer87, 0, 38); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [{binding: 0, resource: {buffer: buffer30}}, {binding: 1, resource: {buffer: buffer38}}], |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, recycledExplicitBindGroupLayout0, veryExplicitBindGroupLayout6], |
| }); |
| let texture133 = device0.createTexture({ |
| size: [24], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup45, new Uint32Array(416), 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer39, 'uint16', 204, 15); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| let imageData16 = new ImageData(24, 16); |
| let texture134 = device0.createTexture({ |
| size: {width: 12}, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView120 = texture15.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder2.drawIndirect(buffer61, 12); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer43, 'uint16', 8, 25); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(1, bindGroup30, new Uint32Array(931), 269, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(5, buffer57, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 1_284, new Uint16Array(2271).map((_, i) => i + 10), 290, 256); |
| } catch {} |
| let texture135 = device0.createTexture({ |
| size: [6], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| let sampler18 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 91.91}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup6, new Uint32Array(513), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(248, 5, 232_915_986); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer40, 76); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer74, 'uint16', 4, 13); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 119, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(472).fill(193), /* required buffer size: 472 */ |
| {offset: 472}, {width: 138, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture136 = device0.createTexture({ |
| size: [48], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture137 = gpuCanvasContext0.getCurrentTexture(); |
| let sampler19 = device0.createSampler({addressModeW: 'repeat', compare: 'always'}); |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer25, 'uint32', 4, 1); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder95.copyTextureToBuffer({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 59, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1386 */ |
| offset: 1386, |
| bytesPerRow: 19200, |
| buffer: buffer56, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder14.pushDebugGroup('\u0648'); |
| } catch {} |
| try { |
| renderBundleEncoder14.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(595).fill(167), /* required buffer size: 595 */ |
| {offset: 595, bytesPerRow: 18}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img2); |
| try { |
| externalTexture7.label = '\u{1fd15}\u{1f9a4}'; |
| } catch {} |
| let texture138 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer7, 32, 65); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer47, 'uint16', 4, 2); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let bindGroup52 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 20, resource: {buffer: buffer77}}]}); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let textureView121 = texture135.createView({}); |
| let texture139 = device0.createTexture({size: [48, 48, 47], format: 'rg8uint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| renderPassEncoder2.drawIndirect(buffer61, 20); |
| } catch {} |
| let gpuCanvasContext4 = canvas3.getContext('webgpu'); |
| let commandEncoder104 = device0.createCommandEncoder(); |
| let textureView122 = texture138.createView({mipLevelCount: 1}); |
| let textureView123 = texture34.createView({}); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup45, []); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer93, 0); |
| } catch {} |
| try { |
| commandEncoder94.copyBufferToBuffer(buffer93, 0, buffer85, 348, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 1, |
| origin: {x: 26, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(2_176).fill(218), /* required buffer size: 2_176 */ |
| {offset: 10, bytesPerRow: 19, rowsPerImage: 38}, {width: 7, height: 0, depthOrArrayLayers: 4}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup22, new Uint32Array(1472), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(1, 16, 0, -1_937_787_561, 10); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer94, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer94, 20); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(0, buffer77, 0, 161); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder2.drawIndexed(1, 48, 0, 774_632_032, 24); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(1, bindGroup51); |
| } catch {} |
| try { |
| renderBundleEncoder23.insertDebugMarker('\u{1fa71}'); |
| } catch {} |
| let buffer95 = device0.createBuffer({ |
| size: 68, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder2.drawIndexed(1, 63, 0, 215_938_365, 41); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer43, 'uint32', 0, 29); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup10, new Uint32Array(443), 163, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new Uint32Array(36222).map((_, i) => i * 9), 1964, 0); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture12.label; |
| } catch {} |
| let commandEncoder106 = device0.createCommandEncoder(); |
| let commandBuffer4 = commandEncoder41.finish({}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup6, []); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(445, 34, 686_996_093, 29); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(1, 74, 0, 525_857_946, 16); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer62, 12); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer39, 'uint16', 88, 129); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(1, buffer51, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(2, buffer47); |
| } catch {} |
| let pipeline22 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| try { |
| await promise10; |
| } catch {} |
| let bindGroup53 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 35, resource: sampler9}, |
| {binding: 123, resource: textureView8}, |
| {binding: 493, resource: textureView52}, |
| {binding: 353, resource: textureView10}, |
| {binding: 241, resource: textureView76}, |
| {binding: 274, resource: externalTexture4}, |
| ], |
| }); |
| let texture140 = device0.createTexture({ |
| size: [6, 6, 18], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup47); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder106.clearBuffer(buffer47); |
| } catch {} |
| let autogeneratedBindGroupLayout10 = pipeline18.getBindGroupLayout(0); |
| let texture141 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 37}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer95, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(1, buffer29, 48, 45); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 76, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 286, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 332, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let buffer96 = device0.createBuffer({ |
| size: 252, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| renderPassEncoder8.beginOcclusionQuery(80); |
| } catch {} |
| try { |
| renderPassEncoder3.setStencilReference(158); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(35, 2, 135_381_504, 30); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(1, 50, 0, -2_053_528_544, 41); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer40, 20); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(0, buffer77); |
| } catch {} |
| document.body.prepend(img0); |
| let textureView124 = texture119.createView({}); |
| let texture142 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 37}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView125 = texture1.createView({dimension: '2d', baseArrayLayer: 2, arrayLayerCount: 1}); |
| let sampler20 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'linear', minFilter: 'linear'}); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer95, 'uint32', 20, 1); |
| } catch {} |
| try { |
| renderBundleEncoder24.draw(65, 1, 290_840_847); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline6); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer30}}]}); |
| let buffer97 = device0.createBuffer({size: 228, usage: GPUBufferUsage.COPY_SRC}); |
| let texture143 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture144 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 94}, |
| mipLevelCount: 3, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| renderBundleEncoder27.drawIndirect(buffer50, 16); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(3, buffer84, 36, 10); |
| } catch {} |
| let buffer98 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_DST}); |
| let textureView126 = texture105.createView({format: 'r32float'}); |
| let renderBundle14 = renderBundleEncoder27.finish({}); |
| try { |
| renderPassEncoder16.setVertexBuffer(0, buffer88, 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup15, new Uint32Array(555), 56, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(7, buffer41, 0, 0); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 0, resource: textureView57}, |
| {binding: 9, resource: externalTexture6}, |
| {binding: 20, resource: {buffer: buffer60}}, |
| {binding: 2, resource: textureView6}, |
| ], |
| }); |
| let texture145 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| dimension: '2d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder27 = commandEncoder61.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: 145.4, g: -805.1, b: 318.4, a: 524.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let renderBundleEncoder34 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup9, new Uint32Array(237), 46, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder31.setPipeline(pipeline14); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 2, resource: textureView84}, |
| {binding: 9, resource: externalTexture3}, |
| {binding: 20, resource: {buffer: buffer77}}, |
| {binding: 0, resource: textureView57}, |
| ], |
| }); |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let textureView127 = texture145.createView({baseArrayLayer: 5, arrayLayerCount: 3}); |
| let renderBundle15 = renderBundleEncoder24.finish({}); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer1, 'uint16', 102, 20); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer25, 'uint32', 0, 13); |
| } catch {} |
| try { |
| commandEncoder97.copyBufferToBuffer(buffer52, 16, buffer39, 0, 156); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer78, 0, new Float32Array(24081).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.09030)), 1590, 0); |
| } catch {} |
| let pipeline23 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4', constants: {}}}); |
| let bindGroup57 = device0.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 20, resource: {buffer: buffer77}}]}); |
| let computePassEncoder22 = commandEncoder42.beginComputePass(); |
| try { |
| computePassEncoder22.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup48, new Uint32Array(1029), 53, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer84, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer91, 'uint16', 186, 286); |
| } catch {} |
| try { |
| renderBundleEncoder33.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder12.insertDebugMarker('\ua1cb'); |
| } catch {} |
| let texture146 = device0.createTexture({ |
| size: [8, 8, 13], |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView128 = texture93.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture127, |
| mipLevel: 0, |
| origin: {x: 143, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(5).fill(156), /* required buffer size: 5 */ |
| {offset: 5}, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.end(); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer14, 'uint16', 0, 5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(317).fill(240), /* required buffer size: 317 */ |
| {offset: 317, rowsPerImage: 73}, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout11 = pipeline23.getBindGroupLayout(0); |
| let texture147 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 13}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView129 = texture100.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup41, new Uint32Array(2048), 860, 1); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer92, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer15, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderPassEncoder24.insertDebugMarker('\u{1fe98}'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(149).fill(246), /* required buffer size: 149 */ |
| {offset: 149}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer99 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder109 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup37); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer100 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let texture148 = device0.createTexture({ |
| size: [8], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView130 = texture59.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup35, new Uint32Array(604), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(122); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer52, 'uint16', 18, 35); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup2, new Uint32Array(2210), 493, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder25.insertDebugMarker('\u0be9'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12, new Uint32Array(1563).map((_, i) => i * 9), 243, 4); |
| } catch {} |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let texture149 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture150 = gpuCanvasContext1.getCurrentTexture(); |
| let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup19, new Uint32Array(1058), 214, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer25, 'uint16', 8, 2); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(0, buffer75, 8); |
| } catch {} |
| try { |
| commandEncoder74.resolveQuerySet(querySet0, 53, 2, buffer12, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer45, 112, new Float32Array(3563).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.879)), 71, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let textureView131 = texture29.createView({}); |
| try { |
| renderPassEncoder21.draw(79, 0, 402_886_764); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndexed(2, 0, 0, 37_340_947, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(2, buffer2, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(192).fill(92), /* required buffer size: 192 */ |
| {offset: 192, bytesPerRow: 49}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 20, resource: {buffer: buffer49, offset: 0, size: 396}}], |
| }); |
| let texture151 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView132 = texture65.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup35, new Uint32Array(2296), 511, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup15, new Uint32Array(2768), 658, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.draw(26, 0, 1_837_933_853); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndexedIndirect(buffer52, 4); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndirect(buffer4, 12); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder35.setPipeline(pipeline6); |
| } catch {} |
| document.body.prepend(img0); |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }}, |
| {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 97, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 131, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 191, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| {binding: 223, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 254, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let texture152 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView133 = texture134.createView({}); |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder21.draw(253, 0, 445_261_555, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndexed(2, 0, 0, 152_145_565); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer85, 'uint32', 44, 3); |
| } catch {} |
| try { |
| commandEncoder73.insertDebugMarker('\u9300'); |
| } catch {} |
| try { |
| computePassEncoder4.insertDebugMarker('\u2309'); |
| } catch {} |
| let canvas4 = document.createElement('canvas'); |
| let textureView134 = texture143.createView({dimension: '2d-array', aspect: 'all', format: 'r32uint', baseMipLevel: 0, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder25.beginOcclusionQuery(80); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder21.draw(164, 0, 376_157_034); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndirect(buffer62, 8); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(1, buffer47, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer91, 'uint16', 0, 101); |
| } catch {} |
| try { |
| buffer58.unmap(); |
| } catch {} |
| try { |
| commandEncoder110.resolveQuerySet(querySet1, 9, 1, buffer51, 0); |
| } catch {} |
| try { |
| commandEncoder64.insertDebugMarker('\u{1f6ee}'); |
| } catch {} |
| let pipeline24 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4', constants: {}}}); |
| let buffer101 = device0.createBuffer({size: 110, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let commandBuffer5 = commandEncoder27.finish(); |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup1, new Uint32Array(3238), 85, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.draw(311, 0, 187_415_299, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndexed(2, 0, 0, 105_090_219); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndirect(buffer50, 8); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(2, bindGroup54, new Uint32Array(523), 18, 0); |
| } catch {} |
| try { |
| renderBundleEncoder35.drawIndexedIndirect(buffer42, 16); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToTexture({ |
| /* bytesInLastRow: 142 widthInBlocks: 71 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 332 */ |
| offset: 332, |
| buffer: buffer60, |
| }, { |
| texture: texture43, |
| mipLevel: 1, |
| origin: {x: 59, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 71, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| let texture153 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 21}, |
| mipLevelCount: 2, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundle16 = renderBundleEncoder35.finish({}); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup13, new Uint32Array(1337), 198, 0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder21.draw(59, 0, 145_790_958); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndirect(buffer1, 132); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline21); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let buffer102 = device0.createBuffer({size: 192, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: false}); |
| try { |
| renderPassEncoder16.executeBundles([renderBundle2, renderBundle2, renderBundle2, renderBundle16]); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndexed(2, 0, 0, 909_204_926); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer74, 'uint32', 4, 7); |
| } catch {} |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer51, 'uint32', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(0, buffer57); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer98, 0, new DataView(new Uint8Array(3729).map((_, i) => i).buffer), 537, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let bindGroup59 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [ |
| {binding: 0, resource: textureView10}, |
| {binding: 9, resource: externalTexture10}, |
| {binding: 20, resource: {buffer: buffer49}}, |
| ], |
| }); |
| let commandEncoder113 = device0.createCommandEncoder(); |
| let commandBuffer6 = commandEncoder18.finish({}); |
| try { |
| renderPassEncoder21.draw(7, 0, 30_218_861); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer39, 'uint16', 8, 390); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(76); }; |
| } catch {} |
| let buffer103 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| let commandBuffer7 = commandEncoder9.finish(); |
| let textureView135 = texture59.createView({}); |
| try { |
| renderPassEncoder21.drawIndexed(2, 0, 0, 52_380_273, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.drawIndirect(buffer93, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup47, new Uint32Array(1417), 652, 0); |
| } catch {} |
| let videoFrame23 = videoFrame13.clone(); |
| let bindGroup60 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer85}}, |
| {binding: 0, resource: textureView44}, |
| {binding: 168, resource: textureView28}, |
| {binding: 141, resource: sampler14}, |
| {binding: 1, resource: {buffer: buffer60}}, |
| ], |
| }); |
| let commandBuffer8 = commandEncoder73.finish({label: '\ua303\u{1faa3}\u4604\u0d10\u0bad\u{1fee9}'}); |
| let texture154 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 28}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView136 = texture15.createView({dimension: '2d', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer100, 'uint32', 80, 3); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 88, new Float64Array(7379).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/7377)), 450, 0); |
| } catch {} |
| let commandBuffer9 = commandEncoder22.finish(); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder21.end(); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer39, 'uint32', 44, 17); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer96, 'uint16', 34, 7); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer98, 4, new Float32Array(7806).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4281)), 537, 4); |
| } catch {} |
| let buffer104 = device0.createBuffer({size: 28, usage: GPUBufferUsage.STORAGE}); |
| let textureView137 = texture97.createView({format: 'rgba32float', mipLevelCount: 1}); |
| let textureView138 = texture55.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup15, new Uint32Array(616), 72, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer25, 'uint32', 8, 1); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9, commandBuffer6, commandBuffer5]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer87, 100, new Uint32Array(33832).map((_, i) => i * 2), 3853, 4); |
| } catch {} |
| let commandBuffer10 = commandEncoder40.finish(); |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(2294), 691, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer39, 'uint16', 68, 3); |
| } catch {} |
| try { |
| renderBundleEncoder36.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder33.setPipeline(pipeline15); |
| } catch {} |
| try { |
| buffer30.destroy(); |
| } catch {} |
| let buffer105 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let texture155 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 41}, |
| mipLevelCount: 2, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer91, 'uint16', 8, 58); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let buffer106 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let texture156 = device0.createTexture({ |
| size: [6], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView139 = texture55.createView({aspect: 'all'}); |
| let sampler21 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 91.19, lodMaxClamp: 96.01}); |
| try { |
| renderPassEncoder25.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer74, 'uint16', 2, 0); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup24, new Uint32Array(168), 28, 0); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(3, buffer102); |
| } catch {} |
| try { |
| commandEncoder81.clearBuffer(buffer29); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 28, new Float16Array(694).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.7787)), 230, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline25 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: {module: shaderModule3, entryPoint: 'vertex2', constants: {}, buffers: []}, |
| primitive: {frontFace: 'cw', cullMode: 'front', unclippedDepth: false}, |
| }); |
| document.body.append(canvas4); |
| let bindGroup61 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 194, resource: externalTexture1}, |
| {binding: 108, resource: sampler7}, |
| {binding: 0, resource: {buffer: buffer72}}, |
| {binding: 2, resource: textureView19}, |
| {binding: 16, resource: externalTexture5}, |
| ], |
| }); |
| let texture157 = device0.createTexture({ |
| size: [163], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder8.beginOcclusionQuery(246); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(0, buffer29); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer100, 'uint16', 34, 15); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(7, buffer106, 0, 1); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8, commandBuffer1]); |
| } catch {} |
| document.body.append(canvas1); |
| try { |
| adapter0.label = '\u0f57\u7455\ua83e\u6597\u8144\u5c2b\u82c5'; |
| } catch {} |
| let buffer107 = device0.createBuffer({size: 56, usage: GPUBufferUsage.COPY_DST}); |
| let texture158 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 13}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer47, 'uint32', 0, 3); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer2, 4, buffer103, 4, 0); |
| } catch {} |
| let pipeline26 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| fragment: {module: shaderModule6, constants: {}, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL}]}, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 120, |
| attributes: [ |
| {format: 'float32', offset: 4, shaderLocation: 15}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 9}, |
| {format: 'uint32x3', offset: 12, shaderLocation: 11}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 2}, |
| {format: 'float32x3', offset: 36, shaderLocation: 12}, |
| {format: 'float16x2', offset: 0, shaderLocation: 1}, |
| {format: 'float32x3', offset: 28, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw'}, |
| }); |
| let gpuCanvasContext5 = canvas4.getContext('webgpu'); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(58); }; |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup23, new Uint32Array(153), 37, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(1, buffer94, 0, 5); |
| } catch {} |
| try { |
| buffer60.unmap(); |
| } catch {} |
| let textureView140 = texture21.createView({dimension: '2d'}); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup40, new Uint32Array(397), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer102, 'uint16', 6, 66); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 327, height: 1, depthOrArrayLayers: 21} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture153, |
| mipLevel: 0, |
| origin: {x: 100, y: 0, z: 12}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup57); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer85, 'uint32', 28, 52); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer87); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup62 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 0, resource: {buffer: buffer37, size: 64}}], |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let texture159 = device0.createTexture({ |
| size: [48, 48, 150], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer95, 'uint32', 4, 10); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer35, 4); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup38); |
| } catch {} |
| let bindGroup63 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 0, resource: {buffer: buffer79, size: 68}}], |
| }); |
| let buffer108 = device0.createBuffer({ |
| size: 112, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let textureView141 = texture56.createView({label: '\ud7d1\ue46d\u0aca\u0781\ub58a\u{1f7f8}', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder8.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup19, new Uint32Array(830), 114, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer77, 'uint16', 14, 1); |
| } catch {} |
| try { |
| buffer106.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer40, 48, new DataView(new ArrayBuffer(29452)), 1686, 8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 6, height: 6, depthOrArrayLayers: 18} |
| */ |
| { |
| source: img1, |
| origin: { x: 0, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'film', transfer: 'iec61966-2-1'} }); |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let autogeneratedBindGroupLayout12 = pipeline4.getBindGroupLayout(0); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder27.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer35, 0, 4); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthReadOnly: true}); |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup46, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup7); |
| } catch {} |
| let buffer109 = device0.createBuffer({size: 16, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup16, new Uint32Array(5458), 458, 0); |
| } catch {} |
| try { |
| buffer58.unmap(); |
| } catch {} |
| try { |
| commandEncoder105.copyTextureToTexture({ |
| texture: texture148, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 34, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let promise18 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4', constants: {}}}); |
| let imageData17 = new ImageData(44, 20); |
| let texture160 = device0.createTexture({size: [1310], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView142 = texture104.createView({dimension: '2d', format: 'astc-10x6-unorm-srgb', mipLevelCount: 1}); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup55, new Uint32Array(1285), 42, 0); |
| } catch {} |
| let pipeline27 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule5, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE}]}, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint8x2', offset: 0, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 1}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 15}, |
| {format: 'float16x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 13}, |
| {format: 'float32x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 14}, |
| {format: 'float32x2', offset: 0, shaderLocation: 4}, |
| {format: 'float32', offset: 0, shaderLocation: 6}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 9}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 0}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10}, |
| {format: 'float32', offset: 0, shaderLocation: 2}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte240m', transfer: 'smpte240m'} }); |
| let bindGroup64 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 20, resource: {buffer: buffer77, offset: 0}}], |
| }); |
| let texture161 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 10}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder28 = commandEncoder83.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView82, |
| depthSlice: 133, |
| clearValue: { r: -713.6, g: -872.6, b: -486.5, a: 352.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.45, |
| compare: 'less-equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup0, new Uint32Array(5713), 993, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup37, new Uint32Array(1200), 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer93.unmap(); |
| } catch {} |
| let bindGroup65 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 1, resource: {buffer: buffer6}}, {binding: 0, resource: {buffer: buffer88}}], |
| }); |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup31, new Uint32Array(2019), 202, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(1, bindGroup1, []); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup15, new Uint32Array(1167), 216, 0); |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpteSt4281', transfer: 'gamma28curve'} }); |
| let bindGroup66 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 1, resource: {buffer: buffer105, size: 128}}], |
| }); |
| let textureView143 = texture0.createView({dimension: '2d-array', aspect: 'all'}); |
| let texture162 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup61, new Uint32Array(2606), 42, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer84, 60); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(2, buffer35, 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer39, 'uint32', 196, 26); |
| } catch {} |
| try { |
| await buffer10.mapAsync(GPUMapMode.READ); |
| } catch {} |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let texture163 = device0.createTexture({ |
| size: [8, 8, 13], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder29 = commandEncoder47.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: 920.1, g: 501.2, b: 624.3, a: 570.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer101, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer76, 100); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer60, 'uint16', 70, 3); |
| } catch {} |
| try { |
| commandEncoder90.clearBuffer(buffer0); |
| } catch {} |
| try { |
| commandEncoder60.resolveQuerySet(querySet0, 50, 1, buffer58, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 6, height: 6, depthOrArrayLayers: 18} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout13 = pipeline18.getBindGroupLayout(1); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let texture164 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup13, new Uint32Array(200), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer84, 116); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer100, 'uint32', 40, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(7, buffer40, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(282, 1, 147_330_726); |
| } catch {} |
| try { |
| renderBundleEncoder14.drawIndexedIndirect(buffer83, 4); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline11); |
| } catch {} |
| let arrayBuffer6 = buffer10.getMappedRange(0, 0); |
| try { |
| buffer55.unmap(); |
| } catch {} |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| let textureView144 = texture36.createView({dimension: '2d-array'}); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame8}); |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let recycledExplicitBindGroupLayout1 = pipeline16.getBindGroupLayout(1); |
| let texture165 = device0.createTexture({ |
| size: [1310, 1, 17], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture166 = device0.createTexture({size: {width: 12}, dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.COPY_SRC}); |
| let texture167 = gpuCanvasContext4.getCurrentTexture(); |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup39, new Uint32Array(3647), 417, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer24, 'uint16', 10, 1); |
| } catch {} |
| try { |
| renderBundleEncoder31.setBindGroup(1, bindGroup0, new Uint32Array(7261), 2_171, 0); |
| } catch {} |
| try { |
| commandEncoder71.copyTextureToTexture({ |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 8, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING, colorSpace: 'srgb'}); |
| } catch {} |
| let commandEncoder122 = device0.createCommandEncoder(); |
| let textureView145 = texture163.createView({dimension: '2d', baseArrayLayer: 1}); |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer108, 12); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 163, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 10, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture164, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 68, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup67 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 9, resource: externalTexture10}, |
| {binding: 0, resource: textureView145}, |
| {binding: 2, resource: textureView119}, |
| {binding: 20, resource: {buffer: buffer60}}, |
| ], |
| }); |
| let buffer110 = device0.createBuffer({size: 360, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder123 = device0.createCommandEncoder({}); |
| let textureView146 = texture106.createView({baseArrayLayer: 0}); |
| let renderBundle17 = renderBundleEncoder14.finish({}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup4, new Uint32Array(571), 13, 0); |
| } catch {} |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer83, 'uint16', 0, 81); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let textureView147 = texture134.createView({}); |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer85, 'uint32', 16, 12); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let textureView148 = texture71.createView({dimension: '2d', baseArrayLayer: 3}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup3, new Uint32Array(903), 190, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(7, buffer106); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline27); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup59, []); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer4, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer93, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline7); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| document.body.append(img0); |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer24, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer84, 52, new DataView(new ArrayBuffer(2683)), 97, 8); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer1, 8); |
| } catch {} |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 140}); |
| let renderPassEncoder30 = commandEncoder71.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView82, |
| depthSlice: 91, |
| clearValue: { r: 526.3, g: 922.4, b: 814.7, a: -8.642, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 112044001, |
| }); |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer4, 0); |
| } catch {} |
| document.body.append(img2); |
| let commandEncoder126 = device0.createCommandEncoder({label: '\ud366\udff9\u{1fcf0}\u92f2\u{1f830}\u764f\uf32a\u1b3f\u43e1\u{1fe0d}\u086c'}); |
| let texture168 = device0.createTexture({ |
| size: [6], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup46, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer95, 8); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(0, buffer7, 28, 9); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| let commandEncoder127 = device0.createCommandEncoder(); |
| let textureView149 = texture152.createView({dimension: 'cube-array', aspect: 'all', arrayLayerCount: 6}); |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer106, 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(2, buffer45, 4, 10); |
| } catch {} |
| let pipeline28 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| canvas1.height = 252; |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup1, new Uint32Array(1430), 203, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.beginOcclusionQuery(90); |
| } catch {} |
| try { |
| renderPassEncoder25.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer84, 28); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(3, buffer102, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline21); |
| } catch {} |
| try { |
| computePassEncoder17.insertDebugMarker('\uddae'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 12, new Float32Array(6696).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.431)), 288, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 6, height: 6, depthOrArrayLayers: 18} |
| */ |
| { |
| source: img3, |
| origin: { x: 1, y: 32 }, |
| flipY: false, |
| }, { |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture169 = device0.createTexture({ |
| size: {width: 12}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let texture170 = gpuCanvasContext4.getCurrentTexture(); |
| let textureView150 = texture91.createView({}); |
| try { |
| renderPassEncoder6.drawIndirect(buffer61, 16); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(0, buffer102, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(1, bindGroup7, new Uint32Array(3199), 716, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer51, 'uint32', 8, 24); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline11); |
| } catch {} |
| let pipeline29 = await device0.createRenderPipelineAsync({ |
| label: '\ufc02\ud901\u03d9\u0a5c\u3ba9\ue084\u{1fbe4}\u66c9\u300b\ua4bc', |
| layout: pipelineLayout2, |
| multisample: {count: 1, mask: 0x25c24e6b}, |
| fragment: {module: shaderModule3, entryPoint: 'fragment4', targets: [{format: 'rg8uint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 8, |
| attributes: [ |
| {format: 'uint8x2', offset: 0, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 16, |
| attributes: [ |
| {format: 'sint32', offset: 0, shaderLocation: 9}, |
| {format: 'unorm8x2', offset: 2, shaderLocation: 12}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 1}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 2}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| await gc(); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup7, new Uint32Array(370), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder30.setPipeline(pipeline21); |
| } catch {} |
| let commandEncoder128 = device0.createCommandEncoder({label: '\udba9\u08df\uc20b\u8699\u0b81'}); |
| let textureView151 = texture14.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder16.drawIndexed(0, 1, 0, 189_424_692); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(6, buffer75, 0, 37); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 72, new DataView(new ArrayBuffer(51668)), 144, 36); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(61); }; |
| } catch {} |
| let autogeneratedBindGroupLayout14 = pipeline10.getBindGroupLayout(0); |
| let buffer111 = device0.createBuffer({ |
| size: 453, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, |
| }); |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer94, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder108.copyTextureToTexture({ |
| texture: texture146, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture89, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline30 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| let texture171 = device0.createTexture({size: [48], dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder16.drawIndirect(buffer48, 8); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(1, buffer35); |
| } catch {} |
| let pipeline31 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 1, mask: 0x2a5ba1c5}, |
| fragment: {module: shaderModule5, constants: {}, targets: [{format: 'rg8uint'}]}, |
| vertex: {module: shaderModule3, entryPoint: 'vertex2', constants: {}, buffers: []}, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: false, |
| }, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 1, 0, -1_808_977_217); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer52, 12); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline29); |
| } catch {} |
| let bindGroup68 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [{binding: 0, resource: {buffer: buffer60}}, {binding: 1, resource: {buffer: buffer7, offset: 0}}], |
| }); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let textureView152 = texture51.createView({}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup33); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 1, 0, 600_039_094); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer94, 4); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer76, 324); |
| } catch {} |
| try { |
| buffer14.unmap(); |
| } catch {} |
| document.body.prepend(img3); |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| let textureView153 = texture91.createView({format: 'rg8uint', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup56, new Uint32Array(2916), 191, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer42, 8); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 6, height: 6, depthOrArrayLayers: 18} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 5}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder131 = device0.createCommandEncoder({label: '\ub751\ue3a6\u56f7\ucc11\u07ba\u0f09\u018f\ubbbf'}); |
| let texture172 = device0.createTexture({ |
| size: [48, 48, 150], |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView154 = texture36.createView({mipLevelCount: 1}); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame17}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer63, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer62, 28); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder32.setVertexBuffer(3, buffer41); |
| } catch {} |
| let recycledExplicitBindGroupLayout2 = pipeline17.getBindGroupLayout(2); |
| let buffer112 = device0.createBuffer({ |
| size: 146, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| try { |
| renderPassEncoder6.drawIndirect(buffer52, 180); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(2, bindGroup19, new Uint32Array(743), 72, 0); |
| } catch {} |
| try { |
| renderBundleEncoder34.insertDebugMarker('\ue0fe'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 42, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(47).fill(3), /* required buffer size: 47 */ |
| {offset: 47}, {width: 697, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder132 = device0.createCommandEncoder({}); |
| let textureView155 = texture138.createView({format: 'rgba32uint', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer112, 8); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer42, 4); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup2, new Uint32Array(6168), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 64_432_442); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup47); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer99.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder30.insertDebugMarker('\u005c'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 0, new DataView(new Uint8Array(16250).map((_, i) => i).buffer), 3862, 0); |
| } catch {} |
| let imageData18 = new ImageData(60, 148); |
| let texture173 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 10}, |
| mipLevelCount: 3, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler23 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 84.87, |
| maxAnisotropy: 12, |
| }); |
| try { |
| renderPassEncoder8.draw(61, 0, 331_472_262); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 314, 0, 88_734_176, 215_166_523); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer76, 180); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder119.copyTextureToBuffer({ |
| texture: texture149, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 116 widthInBlocks: 58 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3768 */ |
| offset: 3768, |
| bytesPerRow: 4608, |
| buffer: buffer56, |
| }, {width: 58, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup61, new Uint32Array(406), 57, 0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup47); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer95, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new Uint16Array(221).map((_, i) => i + 7), 119, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(37); }; |
| } catch {} |
| let imageData19 = new ImageData(8, 80); |
| try { |
| renderPassEncoder26.setVertexBuffer(1, buffer55, 52); |
| } catch {} |
| let arrayBuffer7 = buffer10.getMappedRange(16, 4); |
| try { |
| device0.queue.writeBuffer(buffer77, 100, new Float32Array(10586).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.5431)), 634, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(57); }; |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| await gc(); |
| let bindGroup69 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout12, |
| entries: [{binding: 0, resource: {buffer: buffer32, offset: 0, size: 60}}], |
| }); |
| let buffer113 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_SRC}); |
| let renderPassEncoder31 = commandEncoder103.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView137, |
| depthSlice: 8, |
| clearValue: { r: -181.7, g: 371.0, b: -804.4, a: 264.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, -1_966_658_172); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer111, 252); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer50, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer52, 'uint32', 20, 51); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 12, new DataView(new ArrayBuffer(78524)), 663, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture153, |
| mipLevel: 1, |
| origin: {x: 13, y: 0, z: 6}, |
| aspect: 'all', |
| }, new Uint8Array(240_148).fill(123), /* required buffer size: 240_148 */ |
| {offset: 36, bytesPerRow: 698, rowsPerImage: 43}, {width: 35, height: 0, depthOrArrayLayers: 9}); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let texture174 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup9, new Uint32Array(962), 62, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(145, 0, 1_611_284_484); |
| } catch {} |
| try { |
| renderBundleEncoder36.setBindGroup(0, bindGroup62, new Uint32Array(819), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 430, 0, 161_548_825, 519_170_226); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndexedIndirect(buffer112, 36); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer91, 'uint16', 104, 234); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1310, height: 1, depthOrArrayLayers: 13} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture147, |
| mipLevel: 0, |
| origin: {x: 333, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let textureView156 = texture163.createView({dimension: '2d', baseArrayLayer: 2}); |
| let textureView157 = texture129.createView({label: '\u0e47\ubcd2\u2d3b\u{1fd7f}\u{1f9c9}\u09ca\u6b02\u0178', dimension: '2d-array'}); |
| try { |
| renderPassEncoder16.drawIndirect(buffer95, 20); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndexedIndirect(buffer63, 0); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer1, 'uint32', 116, 71); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(5, buffer84); |
| } catch {} |
| let commandEncoder133 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup66); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(588, 27, 98_431_162, 219_257_274); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer108, 'uint16', 42, 16); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer87, 0, 80); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer94, 40); |
| } catch {} |
| try { |
| buffer96.unmap(); |
| } catch {} |
| try { |
| commandEncoder99.clearBuffer(buffer87); |
| } catch {} |
| try { |
| renderBundleEncoder28.insertDebugMarker('\u9bf3'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer110, 104, new Float32Array(14813).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.240)), 3557, 8); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1310, height: 1, depthOrArrayLayers: 13} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture147, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline32 = await promise18; |
| let pipeline33 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rg8uint'}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 96, |
| attributes: [ |
| {format: 'unorm8x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 15}, |
| {format: 'float32', offset: 20, shaderLocation: 10}, |
| {format: 'sint16x2', offset: 20, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 32, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 12, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 48, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true}, |
| }); |
| document.body.append(img0); |
| let bindGroup70 = device0.createBindGroup({ |
| label: '\u1a32\u8144\u0abe', |
| layout: veryExplicitBindGroupLayout11, |
| entries: [{binding: 0, resource: {buffer: buffer105, offset: 0}}, {binding: 1, resource: {buffer: buffer105}}], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup9, new Uint32Array(1787), 154, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer62, 24); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(0, buffer108); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let buffer114 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer1, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(4, buffer39, 36, 26); |
| } catch {} |
| try { |
| commandEncoder55.copyBufferToBuffer(buffer93, 0, buffer106, 0, 0); |
| } catch {} |
| let buffer115 = device0.createBuffer({size: 187, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let textureView158 = texture123.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup26, new Uint32Array(1065), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer83, 16); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer111, 16); |
| } catch {} |
| let buffer116 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let textureView159 = texture4.createView({baseArrayLayer: 4, arrayLayerCount: 4}); |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer62, 4); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer83, 8); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer43, 'uint32', 20, 4); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndexed(2, 0, 0, -1_909_096_895); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline29); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 372, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(121).fill(49), /* required buffer size: 121 */ |
| {offset: 121}, {width: 137, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup13, new Uint32Array(1996), 64, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(94, 0, 300_034_892); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 117_594_655); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer52, 52); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup34, new Uint32Array(603), 257, 0); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(1, buffer115, 12); |
| } catch {} |
| try { |
| commandEncoder114.clearBuffer(buffer60); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer45, 44, new Float32Array(4779).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2282)), 505, 0); |
| } catch {} |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let renderBundle18 = renderBundleEncoder22.finish({}); |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup55, new Uint32Array(5022), 896, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(83, 0, 273_884_331); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer108, 44); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer92, 'uint32', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder33.setPipeline(pipeline12); |
| } catch {} |
| let arrayBuffer8 = buffer10.getMappedRange(8, 0); |
| try { |
| await promise19; |
| } catch {} |
| let commandEncoder136 = device0.createCommandEncoder({}); |
| let texture175 = device0.createTexture({size: [24], dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup0, new Uint32Array(1767), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer108, 20); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup26, new Uint32Array(117), 30, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let canvas5 = document.createElement('canvas'); |
| try { |
| renderBundleEncoder30.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(3, buffer51, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer111, 32, new DataView(new ArrayBuffer(600)), 3, 100); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(imageData18); |
| let autogeneratedBindGroupLayout15 = pipeline28.getBindGroupLayout(0); |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder16.draw(10, 259, 932_376_761, 9_875_524); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 128_310_480, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer51, 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline25); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 8, new DataView(new Uint8Array(35410).map((_, i) => i).buffer), 978, 52); |
| } catch {} |
| let pipeline34 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4, constants: {}}}); |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 79, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView160 = texture73.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup1, new Uint32Array(10000), 3_715, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 2_461_440); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer94, 24); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(0, bindGroup70); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(1, bindGroup13, new Uint32Array(867), 17, 0); |
| } catch {} |
| try { |
| commandEncoder50.clearBuffer(buffer60); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0); }; |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 71, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 102, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 191, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 211, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 294, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 706, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup64, new Uint32Array(831), 196, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(65, 13, 720_403_171, 50_700_909); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 400_443_726); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer63, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer4, 4); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer14, 'uint16', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup70, []); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer25, 'uint16', 0, 1); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToTexture({ |
| texture: texture153, |
| mipLevel: 0, |
| origin: {x: 58, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture173, |
| mipLevel: 1, |
| origin: {x: 26, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| document.body.append(canvas0); |
| let texture176 = device0.createTexture({ |
| size: {width: 24, height: 24, depthOrArrayLayers: 60}, |
| mipLevelCount: 1, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture177 = device0.createTexture({ |
| size: [655, 1, 1], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder16.drawIndirect(buffer61, 16); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer60, 'uint32', 92, 194); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup66, new Uint32Array(1807), 113, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(7, buffer94, 0, 145); |
| } catch {} |
| let imageData20 = new ImageData(4, 52); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let textureView161 = texture176.createView({baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| renderBundleEncoder29.setBindGroup(0, bindGroup68); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| try { |
| commandEncoder87.copyBufferToBuffer(buffer33, 0, buffer93, 0, 0); |
| } catch {} |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder6.end(); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer83, 64); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer108, 28); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(2, bindGroup37, new Uint32Array(1316), 18, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| document.body.append(canvas4); |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| label: '\u17ef\uf3e9\ua9b9\ufb2c\u040e\u3268\uf67e', |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', minBindingSize: 20, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer117 = device0.createBuffer({size: 77, usage: GPUBufferUsage.INDEX}); |
| let texture178 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 41}, |
| sampleCount: 1, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView162 = texture121.createView({dimension: '2d-array', mipLevelCount: 2}); |
| try { |
| renderPassEncoder16.draw(203, 97, 195_567_155, 523_740_746); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 107_695_984); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer85, 'uint16', 110, 75); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline31); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 163, height: 1, depthOrArrayLayers: 10} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 1, y: 27 }, |
| flipY: true, |
| }, { |
| texture: texture173, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline35 = await device0.createRenderPipelineAsync({ |
| label: '\u{1f85c}\u0aa8\u190c\u9ce8', |
| layout: 'auto', |
| multisample: {count: 1, mask: 0x317c9e4a}, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment6', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 1340, |
| attributes: [ |
| {format: 'float32', offset: 64, shaderLocation: 0}, |
| {format: 'unorm8x2', offset: 214, shaderLocation: 6}, |
| {format: 'unorm10-10-10-2', offset: 512, shaderLocation: 8}, |
| {format: 'float16x4', offset: 380, shaderLocation: 1}, |
| {format: 'uint32x4', offset: 568, shaderLocation: 15}, |
| {format: 'unorm10-10-10-2', offset: 224, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 220, shaderLocation: 10}, |
| {format: 'sint8x4', offset: 156, shaderLocation: 13}, |
| ], |
| }, |
| { |
| arrayStride: 56, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'float32', offset: 0, shaderLocation: 2}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 14}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 5}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 11}, |
| {format: 'float32x2', offset: 20, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 452, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x3', offset: 32, shaderLocation: 4}], |
| }, |
| ], |
| }, |
| primitive: {unclippedDepth: true}, |
| }); |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte432', transfer: 'iec6196624'} }); |
| let bindGroup71 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 20, resource: {buffer: buffer60, offset: 0}}], |
| }); |
| let commandBuffer11 = commandEncoder16.finish(); |
| let texture179 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture180 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 18}, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(379, 106, 562_325_010, 349_645_052); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer102, 'uint32', 52, 39); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 240, new Uint32Array(2551).map((_, i) => i * 10), 601, 12); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 13} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline36 = await promise5; |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| let textureView163 = texture138.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder16.drawIndexed(1, 23, 0, 334_042_009, 1_030_587_679); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer1, 56); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| let texture181 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 18}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture182 = device0.createTexture({ |
| size: [8, 8, 8], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder32 = commandEncoder76.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView82, |
| depthSlice: 38, |
| clearValue: { r: -375.6, g: -774.6, b: 562.7, a: 204.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| maxDrawCount: 122064064, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup33, new Uint32Array(345), 94, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.beginOcclusionQuery(129); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(0, buffer55, 0, 6); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let bindGroup72 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 79, resource: textureView46}, |
| {binding: 0, resource: textureView110}, |
| {binding: 2, resource: {buffer: buffer72}}, |
| ], |
| }); |
| let texture183 = device0.createTexture({ |
| size: {width: 12}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView164 = texture120.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let sampler24 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 60.24}); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder8.draw(103, 0, 1_987_470_548); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let textureView165 = texture181.createView({aspect: 'all'}); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup70, new Uint32Array(2057), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer111, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture184 = device0.createTexture({ |
| size: {width: 1310}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture185 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 87.73, |
| lodMaxClamp: 88.48, |
| compare: 'less-equal', |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup2, new Uint32Array(2059), 686, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(57, 11, 1_702_664_773, 3_214_444_209); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(3, buffer115, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 1, depthOrArrayLayers: 10} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture173, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let img4 = await imageWithData(102, 17, '#10101010', '#20202020'); |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'pq'} }); |
| let textureView166 = texture184.createView({}); |
| let texture186 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView167 = texture112.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder8.draw(83, 0, 44_614_145); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer1, 24); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup8, new Uint32Array(1603), 114, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 288, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture187 = device0.createTexture({ |
| size: [8, 8, 13], |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder8.drawIndirect(buffer108, 16); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer95, 'uint16', 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline21); |
| } catch {} |
| try { |
| buffer115.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture124, |
| mipLevel: 3, |
| origin: {x: 7, y: 0, z: 10}, |
| aspect: 'all', |
| }, new Uint8Array(587).fill(4), /* required buffer size: 587 */ |
| {offset: 291, bytesPerRow: 37, rowsPerImage: 8}, {width: 7, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(1, 223, 0, 132_629_323, 539_743_407); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer95, 8); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(0, buffer102, 0, 11); |
| } catch {} |
| try { |
| commandEncoder91.copyTextureToBuffer({ |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 37, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5402 */ |
| offset: 5402, |
| bytesPerRow: 4608, |
| buffer: buffer56, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline37 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let gpuCanvasContext6 = canvas5.getContext('webgpu'); |
| try { |
| renderPassEncoder25.beginOcclusionQuery(137); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(52, 35, 842_707_129, 1_061_748_237); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(1, 452, 0, 722_730_905, 322_531); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer96, 4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline35); |
| } catch {} |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let texture188 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder16.draw(39, 42, 313_555_071, 530_921_205); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer115, 28); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| buffer91.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let sampler26 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup40, new Uint32Array(2744), 348, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(3, bindGroup27, new Uint32Array(4948), 230, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(557, 0, 80_125_957); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer52, 64); |
| } catch {} |
| try { |
| buffer94.unmap(); |
| } catch {} |
| let commandEncoder142 = device0.createCommandEncoder(); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame19}); |
| try { |
| renderPassEncoder10.setStencilReference(1233); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer83, 'uint32', 0, 1); |
| } catch {} |
| let commandEncoder143 = device0.createCommandEncoder(); |
| let texture189 = device0.createTexture({ |
| size: [48, 48, 19], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup1, new Uint32Array(691), 98, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(1, 59, 0, -2_141_594_115, 720_481_421); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer84, 96); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({layout: autogeneratedBindGroupLayout14, entries: [{binding: 0, resource: {buffer: buffer49}}]}); |
| let textureView168 = texture163.createView({dimension: '2d', baseArrayLayer: 2}); |
| let texture190 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 65}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(1201), 634, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.setBlendConstant({ r: 366.1, g: -844.5, b: 593.7, a: 683.9, }); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, -1_776_345_541); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer52, 56); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup55); |
| } catch {} |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer93, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(3, buffer40, 0); |
| } catch {} |
| try { |
| computePassEncoder21.insertDebugMarker('\u5521'); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer47, 0, new Float32Array(11258).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.593)), 8039, 0); |
| } catch {} |
| document.body.prepend(canvas3); |
| let videoFrame29 = new VideoFrame(canvas0, {timestamp: 0}); |
| try { |
| globalThis.someLabel = sampler5.label; |
| } catch {} |
| let texture191 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 1}, |
| format: 'astc-6x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder32.beginOcclusionQuery(132); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer83, 28); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder8.insertDebugMarker('\u62d5'); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(offscreenCanvas0); |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let renderPassEncoder33 = commandEncoder102.beginRenderPass({ |
| colorAttachments: [{view: textureView82, depthSlice: 46, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 7000120, |
| }); |
| let renderBundleEncoder38 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup9, new Uint32Array(546), 84, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup31, new Uint32Array(903), 39, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(3, bindGroup40, new Uint32Array(4209), 1_690, 0); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 4, new Float32Array(4418).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4395)), 36, 0); |
| } catch {} |
| let buffer118 = device0.createBuffer({ |
| size: 152, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let texture192 = device0.createTexture({ |
| size: {width: 655}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder13.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder25.setBlendConstant({ r: 177.1, g: 902.1, b: -782.0, a: 203.8, }); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(70, 44, 26_254_585, 639_213_133); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer95, 24); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer102, 'uint32', 12, 43); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(60); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup66); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(3, bindGroup13, new Uint32Array(3618), 94, 0); |
| } catch {} |
| try { |
| commandEncoder132.copyTextureToBuffer({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 416 */ |
| offset: 416, |
| bytesPerRow: 512, |
| buffer: buffer39, |
| }, {width: 6, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture11.label; |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [{binding: 0, resource: {buffer: buffer37, size: 104}}, {binding: 1, resource: {buffer: buffer6}}], |
| }); |
| let buffer119 = device0.createBuffer({ |
| size: 100, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let textureView169 = texture98.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 157_856_656, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer83, 96); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer76, 56); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(0, buffer105, 28, 28); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let pipeline38 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex1', |
| buffers: [ |
| { |
| arrayStride: 816, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x2', offset: 36, shaderLocation: 0}, |
| {format: 'snorm16x2', offset: 16, shaderLocation: 8}, |
| {format: 'snorm8x4', offset: 300, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 40, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 248, shaderLocation: 7}, |
| {format: 'uint8x2', offset: 80, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 324, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 32, shaderLocation: 13}, |
| {format: 'float32x4', offset: 156, shaderLocation: 3}, |
| {format: 'uint32', offset: 80, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 4, shaderLocation: 12}, |
| {format: 'uint32x3', offset: 172, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let buffer120 = device0.createBuffer({ |
| size: 112, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture193 = gpuCanvasContext5.getCurrentTexture(); |
| try { |
| renderPassEncoder32.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(2, buffer118, 4); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, -2_122_700_909); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer91, 'uint32', 164, 115); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer57, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder30.setPipeline(pipeline15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer106, 8, new DataView(new Uint8Array(7755).map((_, i) => i).buffer), 831, 0); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| let buffer121 = device0.createBuffer({ |
| size: 528, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView170 = texture180.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder7.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup69, new Uint32Array(1021), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(36, 0, 941_601_630); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(1, 157, 0, 395_344_085, 611_452_873); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer76, 84); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer91, 'uint32', 28, 36); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder101.clearBuffer(buffer29); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer96, 136, new DataView(new ArrayBuffer(36492)), 435, 0); |
| } catch {} |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| let textureView171 = texture115.createView({label: '\u0288\u3987\ubaa7\u04b0\ua128\u0f1d\ua4ea\u4eff'}); |
| let texture194 = device0.createTexture({ |
| size: {width: 1310}, |
| dimension: '1d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer108, 20); |
| } catch {} |
| let textureView172 = texture176.createView({format: 'rg32sint', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 22}); |
| let textureView173 = texture189.createView({dimension: '2d', baseArrayLayer: 6}); |
| try { |
| renderPassEncoder16.draw(156, 25, 168_682_718, 515_899_319); |
| } catch {} |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer77, 'uint32', 164, 20); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(1, buffer2, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline33); |
| } catch {} |
| try { |
| commandEncoder108.clearBuffer(buffer103); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(101).fill(96), /* required buffer size: 101 */ |
| {offset: 101}, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.append(img1); |
| let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'log'} }); |
| try { |
| computePassEncoder19.label = '\ub3ee\u96b3\u0bb7\u35ea\u9b59'; |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 808_076_550, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer101, 12); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(3, buffer120, 0, 38); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer92, 'uint16', 2, 1); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(3, buffer119, 0, 7); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| let texture195 = device0.createTexture({size: {width: 24}, dimension: '1d', format: 'rg16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer76, 72); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer91, 'uint16', 46, 44); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(1, buffer94, 36, 0); |
| } catch {} |
| try { |
| commandEncoder98.copyTextureToTexture({ |
| texture: texture126, |
| mipLevel: 0, |
| origin: {x: 8, y: 38, z: 14}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMaxClamp: 94.54, |
| }); |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(172, 0, 107_970_774); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer1, 132); |
| } catch {} |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer108, 'uint32', 16, 20); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer52, 'uint32', 108, 5); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| await gc(); |
| let buffer122 = device0.createBuffer({label: '\u56bc\u{1f654}', size: 44, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder147 = device0.createCommandEncoder({}); |
| let textureView174 = texture100.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder8.drawIndirect(buffer76, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(4, buffer51, 16, 5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer118, 56, new Float32Array(39255).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.705)), 9863, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer123 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let texture196 = device0.createTexture({ |
| label: '\uca4a\u{1fd35}', |
| size: [1310, 1, 10], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder23.drawIndirect(buffer83, 12); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let imageData21 = new ImageData(48, 72); |
| let buffer124 = device0.createBuffer({ |
| size: 219, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let textureView175 = texture196.createView({dimension: '2d', format: 'rgba16uint', baseArrayLayer: 3}); |
| let texture197 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer52, 4); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer60, 'uint16', 152, 82); |
| } catch {} |
| try { |
| renderBundleEncoder38.setVertexBuffer(0, buffer124, 8); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 56, new Uint32Array(1202).map((_, i) => i * 8), 139, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture198 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView176 = texture87.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup5, new Uint32Array(1354), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer120, 4); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer93, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer118, 0, 14); |
| } catch {} |
| try { |
| commandEncoder56.clearBuffer(buffer45); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 223_437_050); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer61, 4); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(4, buffer105, 0, 23); |
| } catch {} |
| let commandEncoder148 = device0.createCommandEncoder(); |
| let sampler28 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'nearest', lodMaxClamp: 56.42}); |
| try { |
| computePassEncoder22.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup9, new Uint32Array(726), 204, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'bt2020_12bit'} }); |
| try { |
| renderPassEncoder30.setBindGroup(1, bindGroup72); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer40, 8); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer115, 4); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer112, 'uint16', 6, 22); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(1, buffer115, 20, 8); |
| } catch {} |
| try { |
| renderBundleEncoder32.setPipeline(pipeline21); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let texture199 = device0.createTexture({ |
| size: [1310, 1, 32], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView177 = texture71.createView({aspect: 'all', arrayLayerCount: 2}); |
| let renderPassEncoder34 = commandEncoder132.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: 803.8, g: -255.3, b: -743.6, a: -101.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder19.draw(344, 13, 1_036_165_418, 984_110_810); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer112, 12); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| let textureView178 = texture196.createView({dimension: '2d'}); |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer42, 12); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(68); }; |
| } catch {} |
| let videoFrame32 = new VideoFrame(videoFrame3, {timestamp: 0}); |
| let textureView179 = texture179.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 807_245_856, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer76, 76); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 44, new DataView(new ArrayBuffer(5756)), 195, 48); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 13} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 2, y: 16 }, |
| flipY: false, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 13}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder23.draw(20, 0, 1_389_449_693); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexed(0, 6, 0, 220_569_176, 1_599_475_965); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer91, 'uint16', 114, 6); |
| } catch {} |
| try { |
| renderPassEncoder34.setPipeline(pipeline35); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer39, 'uint16', 2, 340); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline38); |
| } catch {} |
| try { |
| commandEncoder55.copyTextureToBuffer({ |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 4, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 320 */ |
| offset: 320, |
| bytesPerRow: 34816, |
| buffer: buffer29, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData22 = new ImageData(12, 148); |
| let buffer125 = device0.createBuffer({size: 584, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView180 = texture164.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, -804_921_399, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer63, 0); |
| } catch {} |
| let commandEncoder150 = device0.createCommandEncoder(); |
| let texture200 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup64); |
| } catch {} |
| try { |
| renderPassEncoder19.draw(10, 333, 315_118_558, 555_081_734); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer4, 36); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer102, 'uint16', 76, 55); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup37, new Uint32Array(3710), 898, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer119, 'uint16', 18, 21); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(3, buffer86, 0, 0); |
| } catch {} |
| try { |
| commandEncoder116.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 4}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 2, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup75 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [ |
| {binding: 20, resource: {buffer: buffer77}}, |
| {binding: 0, resource: textureView10}, |
| {binding: 9, resource: externalTexture1}, |
| ], |
| }); |
| let buffer126 = device0.createBuffer({size: 640, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder151 = device0.createCommandEncoder({}); |
| let texture201 = gpuCanvasContext5.getCurrentTexture(); |
| let textureView181 = texture133.createView({}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup39, new Uint32Array(619), 83, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup69, new Uint32Array(1186), 111, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(150, 0, 3_520_933_900); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer42, 12); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer78, 'uint32', 4, 2); |
| } catch {} |
| let autogeneratedBindGroupLayout16 = pipeline19.getBindGroupLayout(0); |
| let texture202 = gpuCanvasContext5.getCurrentTexture(); |
| let textureView182 = texture82.createView({}); |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup66); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| document.body.append(img2); |
| let textureView183 = texture171.createView({dimension: '1d', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer50, 8); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer24, 'uint16', 6, 10); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let imageBitmap4 = await createImageBitmap(imageData13); |
| let bindGroup76 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer7, offset: 0}}, |
| {binding: 1, resource: {buffer: buffer105, offset: 0, size: 136}}, |
| ], |
| }); |
| let buffer127 = device0.createBuffer({size: 76, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder152 = device0.createCommandEncoder({}); |
| let texture203 = device0.createTexture({ |
| size: [655, 1, 7], |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer112, 16); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer15, 'uint16', 2, 1); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer102, 'uint32', 8, 22); |
| } catch {} |
| try { |
| commandEncoder139.copyTextureToBuffer({ |
| texture: texture99, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 114 */ |
| offset: 114, |
| bytesPerRow: 17664, |
| buffer: buffer0, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(3); }; |
| } catch {} |
| try { |
| renderPassEncoder8.draw(70, 0, 857_020_317); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexed(0, 16, 0, -2_064_671_965, 1_225_156_270); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer50, 40); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(1, bindGroup40, new Uint32Array(467), 6, 0); |
| } catch {} |
| try { |
| commandEncoder55.copyTextureToBuffer({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 676 */ |
| offset: 676, |
| rowsPerImage: 243, |
| buffer: buffer29, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(14); }; |
| } catch {} |
| try { |
| await promise22; |
| } catch {} |
| let commandEncoder153 = device0.createCommandEncoder({}); |
| let textureView184 = texture148.createView({}); |
| try { |
| computePassEncoder21.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup70, new Uint32Array(875), 370, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer112, 52); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer119, 28); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndirect(buffer4, 84); |
| } catch {} |
| try { |
| commandEncoder94.resolveQuerySet(querySet2, 7, 10, buffer99, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u074b'); |
| } catch {} |
| let pipeline39 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL}]}, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 32, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x2', offset: 0, shaderLocation: 15}, |
| {format: 'float16x4', offset: 20, shaderLocation: 1}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 2}, |
| {format: 'snorm8x4', offset: 12, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 11}, |
| {format: 'float32', offset: 4, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup41, [0]); |
| } catch {} |
| try { |
| renderPassEncoder19.draw(206, 86, 422_956_613, 89_917_880); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 359_441_785); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer1, 12); |
| } catch {} |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer108, 'uint16', 22, 40); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(7, buffer88); |
| } catch {} |
| try { |
| renderBundleEncoder21.draw(0, 213, 0, 1_133_712_775); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndexedIndirect(buffer83, 12); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndirect(buffer93, 0); |
| } catch {} |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let texture204 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder35 = commandEncoder115.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView40, |
| clearValue: { r: -343.4, g: -216.1, b: -560.4, a: 867.2, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| }); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame21}); |
| try { |
| renderPassEncoder35.setBindGroup(0, bindGroup37, []); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(7, buffer86, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1310, height: 1, depthOrArrayLayers: 13} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 2, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture147, |
| mipLevel: 0, |
| origin: {x: 79, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let texture205 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle19 = renderBundleEncoder21.finish({}); |
| try { |
| renderPassEncoder19.draw(1_000, 22, 371_749_963, 568_155_134); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexed(0, 182, 0, 176_077_234, 373_215_693); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer94, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer78, 'uint16', 2, 8); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(4, buffer94, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.insertDebugMarker('\u{1fcd2}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer106, 4, new Uint16Array(697).map((_, i) => i + 0), 97, 4); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| let textureView185 = texture182.createView({format: 'rgba32float', mipLevelCount: 1}); |
| try { |
| renderPassEncoder19.draw(5, 21, 955_886_388, 376_734_532); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer63, 0); |
| } catch {} |
| let commandEncoder156 = device0.createCommandEncoder(); |
| let textureView186 = texture42.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 23}); |
| try { |
| renderPassEncoder23.drawIndexed(0, 0, 0, 157_126_180); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer112, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.setIndexBuffer(buffer85, 'uint16', 174, 29); |
| } catch {} |
| let arrayBuffer9 = buffer10.getMappedRange(24, 0); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 13} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 5, y: 7, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture206 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture207 = device0.createTexture({ |
| size: [12, 12, 17], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView187 = texture172.createView({arrayLayerCount: 1}); |
| let computePassEncoder23 = commandEncoder87.beginComputePass(); |
| try { |
| computePassEncoder23.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexed(0, 0, 0, 54_451_500); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer4, 96); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(7, buffer94, 0, 6); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer92, 'uint16', 0, 2); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(37); }; |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexed(0, 672, 0, 1_174_588_624, 1_070_595_160); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 4, height: 4, depthOrArrayLayers: 4} |
| */ |
| { |
| source: img3, |
| origin: { x: 4, y: 49 }, |
| flipY: true, |
| }, { |
| texture: texture182, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData23 = new ImageData(12, 12); |
| let buffer128 = device0.createBuffer({ |
| label: '\u2631\u4550\u{1fdb5}\u{1fe74}\u88b5\u94c7\ude79\uf94b', |
| size: 28, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let texture208 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView188 = texture49.createView({}); |
| let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexed(0, 86, 0, 39_005_413, 820_741_047); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer40, 8); |
| } catch {} |
| let buffer129 = device0.createBuffer({ |
| size: 68, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| let texture209 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 78}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder40 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer129, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup8, new Uint32Array(1362), 258, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer129, 'uint32', 8, 25); |
| } catch {} |
| try { |
| commandEncoder85.resolveQuerySet(querySet1, 86, 3, buffer32, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline40 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let autogeneratedBindGroupLayout17 = pipeline24.getBindGroupLayout(0); |
| let buffer130 = device0.createBuffer({size: 272, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder23.drawIndexed(0, 0, 0, 15_864_453, 0); |
| } catch {} |
| let pipeline41 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}}); |
| let pipeline42 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x3603f0d4}, |
| fragment: {module: shaderModule4, constants: {}, targets: [{format: 'rg8uint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 72, |
| attributes: [ |
| {format: 'uint32x3', offset: 0, shaderLocation: 15}, |
| {format: 'uint32x3', offset: 4, shaderLocation: 5}, |
| {format: 'float16x4', offset: 20, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 1}, |
| {format: 'snorm16x2', offset: 24, shaderLocation: 6}, |
| {format: 'float32x2', offset: 8, shaderLocation: 2}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 13}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'float16x2', offset: 0, shaderLocation: 0}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 9}, |
| {format: 'float16x2', offset: 16, shaderLocation: 3}, |
| {format: 'sint16x4', offset: 12, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 88, |
| attributes: [ |
| {format: 'sint16x4', offset: 20, shaderLocation: 12}, |
| {format: 'float16x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint32x2', offset: 16, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let pipelineLayout5 = device0.createPipelineLayout({ |
| bindGroupLayouts: [autogeneratedBindGroupLayout8, recycledExplicitBindGroupLayout2, veryExplicitBindGroupLayout19, autogeneratedBindGroupLayout1], |
| }); |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let renderPassEncoder36 = commandEncoder127.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView185, |
| depthSlice: 5, |
| clearValue: { r: 959.2, g: 159.8, b: -857.3, a: 17.63, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| let sampler29 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat'}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup19, new Uint32Array(336), 49, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexed(0, 0, 0, 5_361_368); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer39, 'uint16', 98, 102); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer24, 'uint16', 2, 6); |
| } catch {} |
| let commandEncoder161 = device0.createCommandEncoder(); |
| let textureView189 = texture129.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup69, new Uint32Array(4304), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer119, 36); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline17); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'bt2020_10bit'} }); |
| let buffer131 = device0.createBuffer({size: 608, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup34, new Uint32Array(1107), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let pipeline43 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule4, entryPoint: 'fragment5', targets: [{format: 'rg8uint'}]}, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex3', |
| buffers: [ |
| { |
| arrayStride: 72, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 2, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 32, shaderLocation: 12}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 2}, |
| {format: 'float32x3', offset: 0, shaderLocation: 6}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 14}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'sint32x2', offset: 0, shaderLocation: 13}, |
| {format: 'float16x4', offset: 0, shaderLocation: 8}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 15}, |
| {format: 'uint32', offset: 0, shaderLocation: 5}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 4}, |
| {format: 'float16x2', offset: 0, shaderLocation: 9}, |
| ], |
| }, |
| {arrayStride: 128, attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 11}]}, |
| ], |
| }, |
| }); |
| document.body.append(canvas5); |
| let autogeneratedBindGroupLayout18 = pipeline43.getBindGroupLayout(0); |
| let textureView190 = texture178.createView({mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 2}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 81_421_162); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(3, bindGroup23); |
| } catch {} |
| try { |
| renderBundleEncoder36.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder34.setVertexBuffer(2, buffer55, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let buffer132 = device0.createBuffer({size: 32, usage: GPUBufferUsage.VERTEX}); |
| try { |
| renderPassEncoder8.draw(346, 0, 330_946_482); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer115, 16); |
| } catch {} |
| let imageData24 = new ImageData(16, 20); |
| let texture210 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 45}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder41 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup2, new Uint32Array(140), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 170_947_740); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer95, 'uint16', 26, 2); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| let buffer133 = device0.createBuffer({size: 4, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder162 = device0.createCommandEncoder(); |
| let textureView191 = texture36.createView({dimension: '2d-array', aspect: 'all'}); |
| let renderPassEncoder37 = commandEncoder149.beginRenderPass({colorAttachments: [{view: textureView82, depthSlice: 139, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder8.draw(36, 0, 249_444_461); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexed(0, 0, 0, 482_513_012, 0); |
| } catch {} |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(31, 0, 1_141_217_653, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexed(0, 0, 0, 63_184_261); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer95, 0); |
| } catch {} |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, -1_848_874_021); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer62, 24); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer112, 8); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(0, buffer88, 44); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer91, 'uint16', 244, 246); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder100.copyTextureToTexture({ |
| texture: texture111, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture111, |
| mipLevel: 0, |
| origin: {x: 1, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 12, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup77 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout14, |
| entries: [{binding: 0, resource: {buffer: buffer112, size: 84}}], |
| }); |
| let texture211 = device0.createTexture({ |
| size: [655, 1, 7], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup13, new Uint32Array(1223), 110, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer14, 'uint16', 10, 0); |
| } catch {} |
| try { |
| commandEncoder123.resolveQuerySet(querySet2, 50, 0, buffer121, 0); |
| } catch {} |
| let commandEncoder164 = device0.createCommandEncoder({}); |
| let texture212 = device0.createTexture({ |
| size: [48, 48, 58], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView192 = texture140.createView({baseMipLevel: 0, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder33.setStencilReference(1673); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup11); |
| } catch {} |
| let promise25 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute1'}}); |
| let texture213 = device0.createTexture({ |
| size: [48, 48, 150], |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture214 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup41, [0]); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup47, new Uint32Array(1831), 88, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.beginOcclusionQuery(236); |
| } catch {} |
| try { |
| renderPassEncoder19.draw(45, 140, 727_675_734, 2_436_327_752); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder165 = device0.createCommandEncoder(); |
| let textureView193 = texture120.createView({dimension: 'cube-array', aspect: 'all', format: 'rg32uint', baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder19.draw(95, 4, 1_467_916_335, 994_801_433); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 275_245); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer60, 'uint16', 218, 61); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.append(img2); |
| let bindGroup78 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 0, resource: textureView57}, |
| {binding: 2, resource: textureView6}, |
| {binding: 20, resource: {buffer: buffer77}}, |
| {binding: 9, resource: externalTexture5}, |
| ], |
| }); |
| let textureView194 = texture213.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder19.drawIndexed(0, 190, 0, -1_751_780_766, 389_353_701); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer93, 'uint16', 0, 5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer96, 20, new DataView(new ArrayBuffer(81216)), 1242, 24); |
| } catch {} |
| let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470bg', transfer: 'linear'} }); |
| let texture215 = device0.createTexture({ |
| size: [24, 24, 75], |
| dimension: '3d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture216 = device0.createTexture({ |
| size: [24, 24, 1], |
| mipLevelCount: 3, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder23.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 200_570_384); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline12); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| let textureView195 = texture215.createView({dimension: '3d'}); |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 225_042_419); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(3, bindGroup15, new Uint32Array(1463), 200, 0); |
| } catch {} |
| try { |
| renderBundleEncoder39.setIndexBuffer(buffer95, 'uint32', 8, 20); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer87, 4, new Float32Array(9362).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7962)), 133, 24); |
| } catch {} |
| let commandBuffer12 = commandEncoder57.finish(); |
| let texture217 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 655}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView196 = texture106.createView({}); |
| try { |
| renderPassEncoder26.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(187, 0, 1_202_658_656); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer62, 28); |
| } catch {} |
| try { |
| commandEncoder164.copyTextureToBuffer({ |
| texture: texture210, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 8276 */ |
| offset: 2900, |
| bytesPerRow: 5376, |
| buffer: buffer56, |
| }, {width: 0, height: 2, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 60, new Float64Array(3643).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/3640)), 24, 0); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| await gc(); |
| let pipelineLayout6 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, autogeneratedBindGroupLayout4, veryExplicitBindGroupLayout17, autogeneratedBindGroupLayout1], |
| }); |
| let textureView197 = texture211.createView({mipLevelCount: 1}); |
| let sampler30 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 4, |
| }); |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer120, 4); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer111, 'uint32', 36, 23); |
| } catch {} |
| try { |
| await shaderModule2.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12]); |
| } catch {} |
| let texture218 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView198 = texture81.createView({}); |
| try { |
| renderPassEncoder19.drawIndexed(0, 15, 0, 162_902_086, 380_949_483); |
| } catch {} |
| try { |
| renderBundleEncoder33.setPipeline(pipeline11); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| label: '\ue5b7\u{1fac6}\u0c47\uc603\u{1fc39}\u1870\u0942\uac1d\ud790', |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| {binding: 4, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 56, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 73, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| {binding: 88, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 164, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let texture219 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 11}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView199 = texture140.createView({}); |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 490_299_948); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer61, 32); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer112, 32); |
| } catch {} |
| let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'pq'} }); |
| let buffer134 = device0.createBuffer({size: 272, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture220 = device0.createTexture({ |
| size: {width: 12, height: 12, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView200 = texture74.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(2, bindGroup17, new Uint32Array(3428), 664, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 327, height: 1, depthOrArrayLayers: 21} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture153, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData25 = new ImageData(48, 68); |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let textureView201 = texture128.createView({dimension: '2d-array'}); |
| let renderPassEncoder38 = commandEncoder121.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView199, |
| depthSlice: 13, |
| clearValue: { r: 221.4, g: 166.6, b: -827.3, a: -398.5, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder8.draw(91, 0, 559_883_472); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer119, 20); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer83, 88); |
| } catch {} |
| try { |
| computePassEncoder20.insertDebugMarker('\u94b3'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let canvas6 = document.createElement('canvas'); |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder19.draw(9, 21, 646_797_547, 21_792_232); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 172_239_389); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer111, 68); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(0, buffer124); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup37, new Uint32Array(1498), 212, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.drawIndirect(buffer50, 12); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer1, 'uint32', 132, 88); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline35); |
| } catch {} |
| let autogeneratedBindGroupLayout19 = pipeline13.getBindGroupLayout(0); |
| let bindGroup79 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 286, resource: {buffer: buffer88}}, |
| {binding: 1, resource: textureView91}, |
| {binding: 332, resource: {buffer: buffer126, size: 504}}, |
| {binding: 4, resource: {buffer: buffer7, size: 256}}, |
| {binding: 21, resource: externalTexture0}, |
| {binding: 76, resource: textureView19}, |
| {binding: 16, resource: {buffer: buffer124, size: 84}}, |
| ], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(537, 0, 1_688_034_838); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 686_153_187); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline27); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToBuffer(buffer114, 132, buffer103, 4, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 0, new DataView(new Uint8Array(39934).map((_, i) => i).buffer), 12940, 16); |
| } catch {} |
| let bindGroup80 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 9, resource: externalTexture19}, |
| {binding: 2, resource: textureView169}, |
| {binding: 20, resource: {buffer: buffer121}}, |
| {binding: 0, resource: textureView156}, |
| ], |
| }); |
| let commandEncoder169 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer78, 'uint16', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(1, buffer118, 36, 8); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1310, height: 1, depthOrArrayLayers: 13} |
| */ |
| { |
| source: imageData17, |
| origin: { x: 8, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture147, |
| mipLevel: 0, |
| origin: {x: 52, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture221 = device0.createTexture({ |
| label: '\uf9de\u8309\ue1a0\u2de4\u0fac\udd3f\u5751\u{1ff45}\u0623\ue1c9', |
| size: {width: 327}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView202 = texture65.createView({arrayLayerCount: 2}); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(1, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 445_224_162); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(1, bindGroup50); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline35); |
| } catch {} |
| try { |
| commandEncoder68.copyTextureToBuffer({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 20, y: 24, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 880 widthInBlocks: 55 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 592 */ |
| offset: 592, |
| bytesPerRow: 3584, |
| buffer: buffer56, |
| }, {width: 550, height: 16, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| adapter0.label = '\ubb18\u0e0f\u{1f9a8}\u2033\u0c0c\uf67b\u0d14\u5901'; |
| } catch {} |
| let textureView203 = texture57.createView({}); |
| try { |
| renderPassEncoder19.drawIndexed(0, 171, 0, 272_371_845, 1_104_208_664); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer121, 84); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let promise26 = device0.queue.onSubmittedWorkDone(); |
| let pipeline44 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute3'}}); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(13); }; |
| } catch {} |
| document.body.prepend(canvas3); |
| let bindGroup81 = device0.createBindGroup({layout: autogeneratedBindGroupLayout15, entries: [{binding: 20, resource: {buffer: buffer49}}]}); |
| let texture222 = device0.createTexture({ |
| size: [163, 1, 1], |
| dimension: '2d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder14.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup12, new Uint32Array(717), 219, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer52, 36); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| buffer124.unmap(); |
| } catch {} |
| try { |
| commandEncoder124.copyTextureToBuffer({ |
| texture: texture204, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 3680 */ |
| offset: 3680, |
| bytesPerRow: 2560, |
| buffer: buffer56, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise26; |
| } catch {} |
| let buffer135 = device0.createBuffer({size: 276, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder170 = device0.createCommandEncoder(); |
| let textureView204 = texture207.createView({dimension: 'cube'}); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer129, 20); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(2, bindGroup1, new Uint32Array(183), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(1, buffer121, 92, 50); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let gpuCanvasContext7 = canvas6.getContext('webgpu'); |
| let commandEncoder171 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer77, 'uint32', 44, 15); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer119, 'uint16', 22, 9); |
| } catch {} |
| try { |
| renderBundleEncoder38.setVertexBuffer(0, buffer75); |
| } catch {} |
| document.body.prepend(img3); |
| let buffer136 = device0.createBuffer({size: 192, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let textureView205 = texture8.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup45, new Uint32Array(697), 164, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(6, buffer40, 76, 24); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder173 = device0.createCommandEncoder({}); |
| let texture223 = device0.createTexture({ |
| size: {width: 163, height: 1, depthOrArrayLayers: 69}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder19.draw(192, 134, 418_906_562, 260_088_196); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer48, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(6, buffer124, 0, 5); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 0, new BigInt64Array(4176).map((_, i) => BigInt(i - 0)), 160, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 81, height: 1, depthOrArrayLayers: 10} |
| */ |
| { |
| source: videoFrame21, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture173, |
| mipLevel: 1, |
| origin: {x: 26, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let texture224 = device0.createTexture({size: [1310, 1, 1], format: 'rg16sint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup43, new Uint32Array(1877), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(155, 0, 705_398_970, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 575_967_535); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer52, 16); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer83, 48); |
| } catch {} |
| try { |
| commandEncoder147.copyBufferToBuffer(buffer6, 12, buffer98, 12, 0); |
| } catch {} |
| try { |
| commandEncoder60.pushDebugGroup('\ue268'); |
| } catch {} |
| await gc(); |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer101, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup20, new Uint32Array(1712), 14, 0); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| let textureView206 = texture212.createView({label: '\u14ec\u{1fff4}\u{1fe5a}', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 5}); |
| let texture225 = device0.createTexture({size: [8, 8, 13], format: 'rgba32float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let textureView207 = texture188.createView({arrayLayerCount: 1}); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame31, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup20, new Uint32Array(1375), 846, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 151_619_444); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer40, 4); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer29, 0, 142); |
| } catch {} |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| let textureView208 = texture182.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup43, new Uint32Array(4305), 1_005, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(484, 0, 394_908_431); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 310_077_082); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer92, 'uint16', 4, 2); |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 1, resource: {buffer: buffer124, size: 132}}], |
| }); |
| let buffer137 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let textureView209 = texture213.createView({}); |
| try { |
| renderPassEncoder32.setBindGroup(0, bindGroup77); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(22, 0, 621_866_640); |
| } catch {} |
| try { |
| commandEncoder160.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 80 */ |
| offset: 80, |
| buffer: buffer97, |
| }, { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipeline45 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment5', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 15}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 2}, |
| {format: 'float32', offset: 0, shaderLocation: 1}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 9}, |
| {format: 'uint32', offset: 0, shaderLocation: 5}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 13}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 0}, |
| {format: 'float16x2', offset: 0, shaderLocation: 8}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 4}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 14}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 12}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 11}, |
| ], |
| }, |
| {arrayStride: 16, stepMode: 'vertex', attributes: [{format: 'snorm8x4', offset: 0, shaderLocation: 3}]}, |
| ], |
| }, |
| }); |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(55); }; |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout20 = pipeline14.getBindGroupLayout(1); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup42, new Uint32Array(3204), 1_055, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer50, 24); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer51, 'uint16', 8, 10); |
| } catch {} |
| try { |
| commandEncoder66.copyTextureToBuffer({ |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1728 */ |
| offset: 1728, |
| bytesPerRow: 10240, |
| buffer: buffer56, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout21 = pipeline37.getBindGroupLayout(0); |
| let commandEncoder177 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup9, new Uint32Array(74), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(372, 0, 18_384_712); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer4, 24); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder178 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup1, new Uint32Array(475), 49, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(80, 0, 954_987_091); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer84, 40); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer119, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer110, 120, new Uint32Array(10652).map((_, i) => i * 9), 4577, 16); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer77}}]}); |
| let textureView210 = texture32.createView({label: '\u{1f622}\u04c1\u{1f9f6}\u{1f823}'}); |
| let externalTexture23 = device0.importExternalTexture({source: videoFrame28, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup59, new Uint32Array(3260), 222, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let pipeline46 = await promise25; |
| let canvas7 = document.createElement('canvas'); |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder8.draw(142, 0, 904_011_250); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 152_018_704); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer96, 56); |
| } catch {} |
| try { |
| renderBundleEncoder39.setPipeline(pipeline1); |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 108, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout22 = pipeline40.getBindGroupLayout(0); |
| let textureView211 = texture211.createView({dimension: '3d', arrayLayerCount: 1}); |
| try { |
| computePassEncoder5.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(283, 0, 286_448_497, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(1, bindGroup27, new Uint32Array(1205), 453, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setVertexBuffer(1, buffer115, 0, 100); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| } catch {} |
| let videoFrame36 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpteRp431', transfer: 'pq'} }); |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 929_514_332); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer115, 20); |
| } catch {} |
| try { |
| renderBundleEncoder39.setIndexBuffer(buffer77, 'uint16', 28, 31); |
| } catch {} |
| try { |
| renderBundleEncoder33.setVertexBuffer(0, buffer121, 44, 15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer77, 136, new DataView(new Uint8Array(12518).map((_, i) => i).buffer), 1496, 24); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout18, |
| entries: [ |
| {binding: 0, resource: textureView151}, |
| {binding: 9, resource: externalTexture16}, |
| {binding: 20, resource: {buffer: buffer121}}, |
| ], |
| }); |
| let commandEncoder180 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup34, new Uint32Array(2542), 334, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer76, 68); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(0, buffer87, 8, 8); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup5, new Uint32Array(134), 4, 0); |
| } catch {} |
| try { |
| commandEncoder68.copyTextureToTexture({ |
| texture: texture180, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder37.insertDebugMarker('\ubd10'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| } catch {} |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| let textureView212 = texture189.createView({baseArrayLayer: 3, arrayLayerCount: 1}); |
| try { |
| computePassEncoder8.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(295, 0, 1_422_067_070); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 257_459_158); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(4, buffer118, 16); |
| } catch {} |
| let texture226 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView213 = texture67.createView({dimension: '2d-array'}); |
| let sampler31 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 57.38, |
| compare: 'equal', |
| }); |
| let externalTexture24 = device0.importExternalTexture({source: videoFrame32}); |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup45, new Uint32Array(926), 85, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer42, 4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(3, bindGroup26, new Uint32Array(4567), 182, 0); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(0, buffer121, 44, 13); |
| } catch {} |
| await gc(); |
| let commandEncoder182 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup81); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup76, new Uint32Array(606), 68, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(83, 0, 697_471_581); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer121, 192); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer108, 16); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer25, 'uint32', 8, 3); |
| } catch {} |
| let promise27 = device0.queue.onSubmittedWorkDone(); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer38, size: 64}}, |
| {binding: 1, resource: {buffer: buffer37, size: 152}}, |
| ], |
| }); |
| let buffer138 = device0.createBuffer({size: 64, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder19.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(238); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(418, 0, 497_969_388); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(0, buffer118); |
| } catch {} |
| try { |
| commandEncoder119.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 172, y: 0, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture184, |
| mipLevel: 0, |
| origin: {x: 96, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 110, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline47 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| let sampler32 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 89.41, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup41, [0]); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(361, 0, 261_164_944); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer94, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer120, 4); |
| } catch {} |
| try { |
| pipeline5.label = '\u{1f8fa}\u0c59\ud0a7\u40c3\ub5bb\uda6f\u95bf\ud385\u{1f902}\u{1f787}'; |
| } catch {} |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let texture227 = device0.createTexture({ |
| size: {width: 6, height: 6, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture25 = device0.importExternalTexture({source: videoFrame26}); |
| try { |
| renderPassEncoder35.setBindGroup(3, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder43.copyTextureToBuffer({ |
| texture: texture149, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 32 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 98 */ |
| offset: 98, |
| buffer: buffer96, |
| }, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData26 = new ImageData(4, 68); |
| let commandEncoder185 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup34, new Uint32Array(3540), 370, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(354, 0, 179_515_082); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 0, 0, 330_591_115); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer85, 'uint32', 4, 155); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(6, buffer55, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup45, new Uint32Array(1033), 160, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 68, new Float64Array(12507).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/12505)), 212, 0); |
| } catch {} |
| let gpuCanvasContext8 = canvas7.getContext('webgpu'); |
| try { |
| renderPassEncoder8.drawIndirect(buffer63, 4); |
| } catch {} |
| try { |
| commandEncoder91.resolveQuerySet(querySet1, 53, 3, buffer126, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture180, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(283).fill(42), /* required buffer size: 283 */ |
| {offset: 283, rowsPerImage: 3}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise27; |
| } catch {} |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup81, new Uint32Array(494), 116, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.beginOcclusionQuery(382); |
| } catch {} |
| try { |
| renderPassEncoder36.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(46, 0, 242_554_835); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(0, bindGroup66); |
| } catch {} |
| try { |
| globalThis.someLabel = sampler12.label; |
| } catch {} |
| let pipeline48 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout6, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x2', offset: 4, shaderLocation: 12}, |
| {format: 'sint32', offset: 0, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 11}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 2, shaderLocation: 1}, |
| {format: 'float32x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 2}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| gpuCanvasContext7.unconfigure(); |
| } catch {} |
| try { |
| externalTexture15.label = '\u0212\u{1f603}\u959a\u0469\u00c8\u3171\ufaf9\u1293\u05cf\u089e\u0492'; |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 77, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 134, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandBuffer13 = commandEncoder31.finish(); |
| let computePassEncoder24 = commandEncoder56.beginComputePass(); |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup72, new Uint32Array(5330), 337, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(2, buffer102, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer78, 0, new Float32Array(7707).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6511)), 549, 0); |
| } catch {} |
| try { |
| adapter0.label = '\u633e\u0ddd\ub7aa\ud2d4\u5867\u6573'; |
| } catch {} |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 288, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture228 = device0.createTexture({size: [8], dimension: '1d', format: 'rg8uint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| let textureView214 = texture157.createView({dimension: '1d', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder24.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer101, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer1, 'uint16', 44, 8); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 32 */ |
| offset: 32, |
| bytesPerRow: 12288, |
| buffer: buffer33, |
| }, { |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 9, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas2); |
| let textureView215 = texture227.createView({}); |
| let texture229 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 7}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder8.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer112, 'uint16', 14, 55); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 12, height: 12, depthOrArrayLayers: 17} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 34, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture207, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout23 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let texture230 = device0.createTexture({ |
| size: [1310, 1, 8], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder10.executeBundles([renderBundle14, renderBundle17, renderBundle14, renderBundle16, renderBundle8]); |
| } catch {} |
| try { |
| commandEncoder142.copyBufferToTexture({ |
| /* bytesInLastRow: 328 widthInBlocks: 41 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 224 */ |
| offset: 224, |
| bytesPerRow: 1280, |
| buffer: buffer111, |
| }, { |
| texture: texture117, |
| mipLevel: 0, |
| origin: {x: 191, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 41, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer139 = device0.createBuffer({size: 20, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder188 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder30.setStencilReference(981); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup29, new Uint32Array(5411), 3_303, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| let buffer140 = device0.createBuffer({size: 36, usage: GPUBufferUsage.STORAGE}); |
| let texture231 = device0.createTexture({ |
| size: [12, 12, 37], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView216 = texture139.createView({dimension: 'cube', baseMipLevel: 0, baseArrayLayer: 2}); |
| let externalTexture26 = device0.importExternalTexture({source: videoFrame36}); |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup23, []); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup32, new Uint32Array(313), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(3, bindGroup49, new Uint32Array(640), 130, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(2, buffer120, 0, 18); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 20, resource: {buffer: buffer126}}]}); |
| let commandEncoder189 = device0.createCommandEncoder(); |
| let textureView217 = texture98.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder33.beginOcclusionQuery(86); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer115, 12, 9); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(3, bindGroup81, new Uint32Array(123), 5, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm'], |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let pipeline49 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {}}}); |
| let commandEncoder190 = device0.createCommandEncoder({}); |
| let texture232 = device0.createTexture({ |
| size: [327, 1, 85], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView218 = texture53.createView({}); |
| try { |
| renderPassEncoder35.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| buffer115.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 165, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(15).fill(85), /* required buffer size: 15 */ |
| {offset: 15}, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 13} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer141 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture233 = device0.createTexture({ |
| size: {width: 1310}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder30.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| canvas0.height = 650; |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let textureView219 = texture206.createView({dimension: '2d-array', aspect: 'all'}); |
| let textureView220 = texture86.createView({}); |
| let sampler33 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 81.33, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer44, 44, new DataView(new Uint8Array(5692).map((_, i) => i).buffer), 518, 8); |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let textureView221 = texture175.createView({}); |
| try { |
| computePassEncoder21.end(); |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline47); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(7, buffer86, 0, 1); |
| } catch {} |
| try { |
| commandEncoder167.copyBufferToBuffer(buffer62, 24, buffer47, 0, 0); |
| } catch {} |
| try { |
| commandEncoder183.copyTextureToTexture({ |
| texture: texture218, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture12, |
| mipLevel: 6, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder68.resolveQuerySet(querySet1, 49, 0, buffer2, 0); |
| } catch {} |
| let textureView222 = texture207.createView({ |
| label: '\u0aa2\u9f03\u08ec\udb29\u278b', |
| dimension: 'cube-array', |
| baseArrayLayer: 3, |
| arrayLayerCount: 6, |
| }); |
| try { |
| renderPassEncoder24.drawIndexed(3, 1, 0, 207_731_967); |
| } catch {} |
| try { |
| buffer72.unmap(); |
| } catch {} |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 85.04, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder33.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder24.draw(65, 1, 341_549_167); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndexed(2, 1, 0, 392_559_752); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndirect(buffer101, 16); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndirect(buffer121, 8); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder60.popDebugGroup(); |
| } catch {} |
| await gc(); |
| let buffer142 = device0.createBuffer({size: 14272, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder193 = device0.createCommandEncoder(); |
| let texture234 = device0.createTexture({ |
| size: {width: 655, height: 1, depthOrArrayLayers: 16}, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup46, new Uint32Array(2051), 8, 2); |
| } catch {} |
| try { |
| renderPassEncoder24.draw(138, 1, 983_049_687); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer95, 'uint16', 0, 17); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(3, buffer35, 0, 9); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer133, 0, new DataView(new ArrayBuffer(5657)), 1677, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 163, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData25, |
| origin: { x: 12, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture164, |
| mipLevel: 0, |
| origin: {x: 78, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder194 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder24.draw(206, 1, 215_826_418); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndexedIndirect(buffer119, 8); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer47, 'uint16', 2, 10); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndexed(3, 92, 1, 8_354_516, 237_917_801); |
| } catch {} |
| let commandEncoder195 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup72); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndexed(2, 1, 0, 341_398_296); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndirect(buffer82, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer15, 'uint16', 4, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 6, height: 6, depthOrArrayLayers: 18} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture235 = device0.createTexture({ |
| size: [327, 1, 39], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder28.setBindGroup(3, bindGroup62); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(1, buffer57, 0, 1); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer143 = device0.createBuffer({size: 124, usage: GPUBufferUsage.VERTEX}); |
| let texture236 = device0.createTexture({ |
| size: {width: 12}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup26, new Uint32Array(2524), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndexedIndirect(buffer94, 28); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer43, 'uint16', 0, 11); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer83, 'uint16', 44, 44); |
| } catch {} |
| try { |
| renderBundleEncoder33.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(2, buffer35); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Uint16Array(7892).map((_, i) => i + 2), 775, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture207, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(81_812).fill(47), /* required buffer size: 81_812 */ |
| {offset: 131, bytesPerRow: 147, rowsPerImage: 185}, {width: 6, height: 1, depthOrArrayLayers: 4}); |
| } catch {} |
| await gc(); |
| let textureView223 = texture185.createView({format: 'rg16sint'}); |
| let renderPassEncoder39 = commandEncoder81.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView40, |
| clearValue: { r: -786.7, g: 502.7, b: 902.4, a: 404.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet2, |
| }); |
| try { |
| renderPassEncoder24.drawIndexed(2, 1, 0, 279_616_601); |
| } catch {} |
| try { |
| renderPassEncoder24.drawIndexedIndirect(buffer101, 8); |
| } catch {} |
| try { |
| renderBundleEncoder39.setBindGroup(0, bindGroup8, new Uint32Array(90), 9, 0); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndirect(buffer111, 108); |
| } catch {} |
| try { |
| commandEncoder118.copyTextureToTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 2, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 198, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder48.resolveQuerySet(querySet2, 29, 1, buffer12, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline50 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, targets: [{format: 'rg8uint'}]}, |
| vertex: {module: shaderModule3, entryPoint: 'vertex2', buffers: []}, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16'}, |
| }); |
| await gc(); |
| let autogeneratedBindGroupLayout24 = pipeline15.getBindGroupLayout(0); |
| let commandBuffer14 = commandEncoder21.finish(); |
| let sampler35 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', compare: 'not-equal'}); |
| try { |
| renderPassEncoder24.drawIndexedIndirect(buffer42, 4); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndirect(buffer123, 12); |
| } catch {} |
| let pipeline51 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let bindGroup87 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 161, resource: externalTexture22}, {binding: 2, resource: textureView12}], |
| }); |
| let buffer144 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandBuffer15 = commandEncoder34.finish(); |
| let texture237 = device0.createTexture({ |
| size: {width: 655}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(1, bindGroup59, new Uint32Array(60), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle2, renderBundle8]); |
| } catch {} |
| try { |
| renderBundleEncoder40.drawIndexedIndirect(buffer129, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.drawIndirect(buffer15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder39.setPipeline(pipeline39); |
| } catch {} |
| try { |
| commandEncoder97.resolveQuerySet(querySet1, 8, 42, buffer64, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer133, 0, new DataView(new ArrayBuffer(1912)), 62, 0); |
| } catch {} |
| let renderBundle20 = renderBundleEncoder40.finish({}); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup45, new Uint32Array(105), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle17, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer96, 'uint32', 12, 47); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer51); |
| } catch {} |
| try { |
| renderBundleEncoder30.draw(9, 50, 816_889_963, 420_640_698); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndexed(8, 75, 2, 301_658_019, 642_151_876); |
| } catch {} |
| await gc(); |
| let bindGroup88 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer34}}, |
| {binding: 194, resource: externalTexture7}, |
| {binding: 16, resource: externalTexture22}, |
| {binding: 2, resource: textureView105}, |
| {binding: 108, resource: sampler18}, |
| ], |
| }); |
| try { |
| renderPassEncoder29.draw(152, 92, 612_239_703, 1_188_557_337); |
| } catch {} |
| try { |
| renderPassEncoder29.drawIndexedIndirect(buffer61, 16); |
| } catch {} |
| try { |
| renderPassEncoder29.drawIndirect(buffer115, 4); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer24, 'uint16', 0, 1); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(0, buffer88, 16, 101); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndexed(5, 362, 0, -1_621_291_139, 594_907_506); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| try { |
| commandEncoder49.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 2, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder171.resolveQuerySet(querySet2, 4, 0, buffer2, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout25 = pipeline51.getBindGroupLayout(0); |
| let commandEncoder196 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup12, new Uint32Array(2300), 589, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer55, 'uint16', 2, 51); |
| } catch {} |
| let buffer145 = device0.createBuffer({size: 328, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder28.setBindGroup(0, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(2, buffer57, 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(1, bindGroup13, new Uint32Array(747), 365, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.draw(0, 415, 0, 39_311_742); |
| } catch {} |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer77, 'uint32', 172, 75); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| let buffer146 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let textureView224 = texture209.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder29.drawIndirect(buffer120, 40); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(3, bindGroup77, new Uint32Array(4316), 2_104, 0); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer83, 'uint32', 16, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 1, depthOrArrayLayers: 10} |
| */ |
| { |
| source: imageBitmap2, |
| origin: { x: 44, y: 14 }, |
| flipY: false, |
| }, { |
| texture: texture173, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 0, resource: {buffer: buffer81, offset: 0}}], |
| }); |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let texture238 = device0.createTexture({ |
| size: [163, 1, 1], |
| mipLevelCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup76); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup13, new Uint32Array(1005), 280, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.draw(55, 87, 1_071_521_909, 625_086_351); |
| } catch {} |
| try { |
| renderPassEncoder29.drawIndexedIndirect(buffer138, 4); |
| } catch {} |
| try { |
| renderBundleEncoder30.drawIndexedIndirect(buffer4, 16); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(0, buffer143, 0, 29); |
| } catch {} |
| try { |
| commandEncoder123.copyBufferToBuffer(buffer60, 40, buffer96, 8, 132); |
| } catch {} |
| try { |
| renderPassEncoder24.end(); |
| } catch {} |
| try { |
| renderPassEncoder29.drawIndexedIndirect(buffer112, 4); |
| } catch {} |
| try { |
| commandEncoder177.insertDebugMarker('\u2086'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer15]); |
| } catch {} |
| let promise28 = device0.queue.onSubmittedWorkDone(); |
| let textureView225 = texture231.createView({dimension: '3d', aspect: 'all', baseArrayLayer: 0}); |
| let renderBundle21 = renderBundleEncoder30.finish({}); |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup68, []); |
| } catch {} |
| try { |
| renderPassEncoder29.draw(61, 114, 931_891_651, 879_476_844); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline38); |
| } catch {} |
| try { |
| commandEncoder50.insertDebugMarker('\u331b'); |
| } catch {} |
| let pipeline52 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4, constants: {}}}); |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(28); }; |
| } catch {} |
| try { |
| renderPassEncoder29.drawIndexedIndirect(buffer123, 16); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer102, 'uint16', 36, 32); |
| } catch {} |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let texture239 = device0.createTexture({ |
| size: [8, 8, 13], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder29.end(); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer47, 'uint16', 12, 1); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| renderBundleEncoder41.setIndexBuffer(buffer85, 'uint32', 84, 83); |
| } catch {} |
| let imageData27 = new ImageData(40, 8); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup19, []); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup72); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup52, new Uint32Array(4634), 744, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer74, 'uint16', 8, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: {buffer: buffer102}}]}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup75); |
| } catch {} |
| try { |
| renderBundleEncoder28.draw(0, 82, 0, 962_309_286); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndexed(3, 1, 0, 1_183_358_782, 2); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await promise28; |
| } catch {} |
| await gc(); |
| let bindGroup91 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 2, resource: textureView17}, {binding: 161, resource: externalTexture20}], |
| }); |
| let commandBuffer16 = commandEncoder36.finish(); |
| let texture240 = device0.createTexture({ |
| size: {width: 48, height: 48, depthOrArrayLayers: 150}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView226 = texture105.createView({label: '\u31db\u06df\u1368', baseMipLevel: 0}); |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 163, height: 1, depthOrArrayLayers: 78} |
| */ |
| { |
| source: canvas2, |
| origin: { x: 32, y: 15 }, |
| flipY: true, |
| }, { |
| texture: texture209, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 18}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 15, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder199 = device0.createCommandEncoder({}); |
| let textureView227 = texture133.createView({}); |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer77, 'uint32', 32, 42); |
| } catch {} |
| try { |
| renderPassEncoder34.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndirect(buffer123, 20); |
| } catch {} |
| try { |
| commandEncoder45.copyTextureToBuffer({ |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 215, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 302 widthInBlocks: 151 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 182 */ |
| offset: 182, |
| bytesPerRow: 5120, |
| buffer: buffer40, |
| }, {width: 151, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline53 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment4', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x2', offset: 204, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 104, shaderLocation: 15}, |
| {format: 'float32x3', offset: 308, shaderLocation: 1}, |
| {format: 'uint32x3', offset: 556, shaderLocation: 2}, |
| {format: 'float16x2', offset: 68, shaderLocation: 12}, |
| {format: 'unorm16x4', offset: 376, shaderLocation: 10}, |
| ], |
| }, |
| {arrayStride: 64, attributes: [{format: 'sint8x2', offset: 2, shaderLocation: 9}]}, |
| ], |
| }, |
| }); |
| let buffer147 = device0.createBuffer({size: 136, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let texture241 = gpuCanvasContext1.getCurrentTexture(); |
| let sampler36 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 92.17}); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup7, new Uint32Array(87), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer77, 'uint32', 76, 27); |
| } catch {} |
| try { |
| renderBundleEncoder28.draw(0, 64, 0, 107_066_504); |
| } catch {} |
| await gc(); |
| let buffer148 = device0.createBuffer({size: 20, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder200 = device0.createCommandEncoder(); |
| let textureView228 = texture209.createView({mipLevelCount: 1}); |
| let externalTexture27 = device0.importExternalTexture({source: videoFrame25}); |
| try { |
| renderBundleEncoder29.draw(16, 2, 961_192_709); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer55, 'uint32', 0, 36); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await buffer114.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| try { |
| commandEncoder159.copyTextureToTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture184, |
| mipLevel: 0, |
| origin: {x: 347, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 64, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder35.insertDebugMarker('\ub136'); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(3, bindGroup48, new Uint32Array(1056), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderBundleEncoder39.setBindGroup(2, bindGroup61); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndexed(5, 1, 0, 167_015_427); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndirect(buffer4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer1, 'uint16', 56, 75); |
| } catch {} |
| try { |
| renderBundleEncoder39.setPipeline(pipeline43); |
| } catch {} |
| try { |
| await shaderModule6.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder179.resolveQuerySet(querySet0, 4, 1, buffer94, 0); |
| } catch {} |
| let commandEncoder201 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder10.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndexed(3, 1, 1, -1_926_780_995, 1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 8} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture182, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas4); |
| await gc(); |
| let buffer149 = device0.createBuffer({ |
| size: 48, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture242 = device0.createTexture({ |
| label: '\u4b88\u6f90\ub893\u05ff\u849b', |
| size: [48, 48, 8], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder19.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndirect(buffer108, 12); |
| } catch {} |
| try { |
| renderBundleEncoder25.setPipeline(pipeline17); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup92 = device0.createBindGroup({layout: autogeneratedBindGroupLayout25, entries: [{binding: 0, resource: {buffer: buffer118}}]}); |
| let commandEncoder202 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder8.insertDebugMarker('\u1e19'); |
| } catch {} |
| document.body.prepend(img4); |
| let autogeneratedBindGroupLayout26 = pipeline19.getBindGroupLayout(0); |
| let bindGroup93 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [{binding: 144, resource: {buffer: buffer38}}, {binding: 2, resource: textureView32}], |
| }); |
| let texture243 = device0.createTexture({ |
| size: {width: 1310, height: 1, depthOrArrayLayers: 57}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder29.draw(145, 1, 519_980_205, 2); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndexed(4, 1, 0, 470_169_973); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndexedIndirect(buffer123, 20); |
| } catch {} |
| try { |
| renderBundleEncoder29.drawIndirect(buffer142, 1_972); |
| } catch {} |
| try { |
| renderBundleEncoder33.setVertexBuffer(7, buffer2); |
| } catch {} |
| let commandEncoder203 = device0.createCommandEncoder(); |
| let commandBuffer17 = commandEncoder65.finish(); |
| let texture244 = device0.createTexture({ |
| size: {width: 327, height: 1, depthOrArrayLayers: 477}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup83, new Uint32Array(622), 371, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer119, 4, 53); |
| } catch {} |
| try { |
| renderBundleEncoder25.setPipeline(pipeline27); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(184).fill(74), /* required buffer size: 184 */ |
| {offset: 184, bytesPerRow: 29, rowsPerImage: 16}, {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 163, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 4, y: 12 }, |
| flipY: false, |
| }, { |
| texture: texture230, |
| mipLevel: 3, |
| origin: {x: 105, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame16.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| videoFrame29.close(); |
| videoFrame30.close(); |
| videoFrame33.close(); |
| videoFrame35.close(); |
| videoFrame36.close(); |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0(), window1() ]; |
| log('promises created'); |
| let results = await Promise.allSettled(promises); |
| for (let result of results) { |
| if (result.status === 'rejected') { throw result.reason; } |
| } |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| debug('Pass'); |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
