| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script id="shared"> |
| const log = console.log; |
| |
| 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?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({requiredLimits: {maxUniformBufferBindingSize: 1814704, maxStorageBufferBindingSize: 146882510}}); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass({}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer0 = device0.createBuffer({ |
| size: 8513, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture0 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'r8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let computePassEncoder1 = commandEncoder1.beginComputePass({}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'log'} }); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture1 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView0 = texture1.createView({dimension: '2d', aspect: 'all', baseMipLevel: 0}); |
| let computePassEncoder2 = commandEncoder3.beginComputePass({}); |
| let sampler0 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 92.83}); |
| try { |
| buffer0.destroy(); |
| } catch {} |
| try { |
| computePassEncoder2.insertDebugMarker('\u37c4'); |
| } catch {} |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 902}); |
| let texture2 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'depth32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer1 = device0.createBuffer({size: 876, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let computePassEncoder3 = commandEncoder2.beginComputePass({}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer2 = device0.createBuffer({size: 83, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| let commandEncoder4 = device0.createCommandEncoder(); |
| let texture3 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8sint', 'rgba8sint', 'rgba8sint'], |
| }); |
| let computePassEncoder4 = commandEncoder4.beginComputePass({}); |
| let sampler1 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 62.35}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(2, undefined); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 8, new DataView(new ArrayBuffer(32165)), 2542, 4); |
| } catch {} |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let computePassEncoder5 = commandEncoder5.beginComputePass(); |
| let renderBundle0 = renderBundleEncoder0.finish({label: '\u3e3e\u0a41\u8be0\u62a6\u070d'}); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 396, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let sampler2 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 12, |
| }); |
| let buffer3 = device0.createBuffer({size: 6224, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder6 = device0.createCommandEncoder(); |
| let texture4 = device0.createTexture({ |
| size: [60, 20, 4], |
| mipLevelCount: 5, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder6 = commandEncoder6.beginComputePass({}); |
| let sampler3 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 4, |
| }); |
| try { |
| await promise0; |
| } catch {} |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0]}); |
| let sampler4 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMaxClamp: 93.27, |
| }); |
| try { |
| renderBundleEncoder1.setVertexBuffer(3, undefined, 0, 8_115_938); |
| } catch {} |
| let commandEncoder7 = device0.createCommandEncoder(); |
| let textureView1 = texture2.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder7 = commandEncoder7.beginComputePass({}); |
| await gc(); |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let buffer4 = device0.createBuffer({ |
| size: 10736, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder0.label; |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let computePassEncoder8 = commandEncoder8.beginComputePass({}); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| let renderBundle1 = renderBundleEncoder1.finish({}); |
| try { |
| device0.queue.writeBuffer(buffer2, 12, new DataView(new ArrayBuffer(5225)), 1042, 4); |
| } catch {} |
| let buffer5 = device0.createBuffer({size: 15160, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 88.92, |
| compare: 'less', |
| maxAnisotropy: 1, |
| }); |
| await gc(); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 396, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture5 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 21}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler6 = device0.createSampler({ |
| label: '\u4459\u296a\u0bda\u1da6\u{1f6ad}', |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.78, |
| compare: 'not-equal', |
| maxAnisotropy: 6, |
| }); |
| try { |
| globalThis.someLabel = commandEncoder7.label; |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 3072}}], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1]}); |
| let sampler7 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| maxAnisotropy: 1, |
| }); |
| let imageData0 = new ImageData(24, 52); |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let texture6 = device0.createTexture({ |
| size: [60, 20, 1], |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 1792, size: 1784}}], |
| }); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 1090}); |
| let texture7 = device0.createTexture({ |
| size: [30, 10, 16], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView2 = texture4.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder9 = commandEncoder9.beginComputePass({}); |
| try { |
| device0.queue.writeBuffer(buffer4, 1652, new Float32Array(47930), 18062, 1292); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(295).fill(8), /* required buffer size: 295 */ |
| {offset: 295, bytesPerRow: 118}, {width: 60, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 258, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 512}}], |
| }); |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let texture8 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder10 = commandEncoder10.beginComputePass({}); |
| let sampler8 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 72.45}); |
| let texture9 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 35}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView3 = texture2.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup1, new Uint32Array(2174), 327, 0); |
| } catch {} |
| let imageData1 = new ImageData(24, 224); |
| try { |
| buffer4.label = '\u2ae0\ubbcf\u0445\ud1ea\u0324\u8c4f\u{1f76f}\ub101\u{1fb27}\u4360\u0e70'; |
| } catch {} |
| let textureView4 = texture6.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let texture10 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView5 = texture2.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder2.pushDebugGroup('\u{1f87f}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 12, new Int16Array(1379), 401, 4); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| enable f16; |
| |
| enable f16; |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw0: vec4f; |
| |
| var<workgroup> vw1: atomic<i32>; |
| |
| fn fn1() -> VertexOutput0 { |
| var out: VertexOutput0; |
| let ptr14: ptr<storage, array<array<f16, 3>, 3>, read> = &(*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(62))][u32(unconst_u32(234))]; |
| out = VertexOutput0(vec4f(f32((*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(38))][2][2][2]))); |
| let ptr15: ptr<storage, f16, read> = &(*&buffer6)[arrayLength(&(*&buffer6))][0][u32(unconst_u32(74))][2][u32(unconst_u32(103))]; |
| return out; |
| _ = buffer6; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn fn0(a0: ptr<private, array<T0, 1>>) -> array<vec2i, 1> { |
| var out: array<vec2i, 1>; |
| let ptr0: ptr<storage, array<f16, 3>, read> = &buffer6[u32(unconst_u32(60))][0][u32(unconst_u32(45))][2]; |
| let ptr1: ptr<storage, array<array<f16, 3>, 3>, read> = &(*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(247))][u32(unconst_u32(126))]; |
| (*a0)[u32(unconst_u32(8))].f0 -= mat3x3f(f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))]), f32(buffer6[u32(unconst_u32(175))][0][2][u32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(121))][2][2][2])][u32(unconst_u32(864))])); |
| let ptr2: ptr<storage, array<array<f16, 3>, 3>, read> = &buffer6[arrayLength(&buffer6)][0][u32(unconst_u32(60))]; |
| out[u32(unconst_u32(5))] = vec2i(i32((*&buffer6)[u32(unconst_u32(67))][0][u32(unconst_u32(205))][2][u32(unconst_u32(391))])); |
| let ptr3: ptr<storage, f16, read> = &(*ptr1)[u32(unconst_u32(231))][u32(unconst_u32(2))]; |
| out[u32(unconst_u32(168))] ^= vec2i(i32((*&buffer6)[vec3u((*a0)[0].f0[unconst_i32(1)]).x][u32(unconst_u32(303))][2][2][2])); |
| let ptr4: ptr<storage, array<array<f16, 3>, 3>, read> = &buffer6[u32(unconst_u32(265))][u32(unconst_u32(657))][2]; |
| (*a0)[u32(unconst_u32(43))].f0 += mat3x3f(f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2]), f32(buffer6[arrayLength(&buffer6)][u32(unconst_u32(565))][u32(unconst_u32(131))][u32(unconst_u32(120))][2])); |
| let ptr5: ptr<storage, f16, read> = &(*&buffer6)[u32(unconst_u32(151))][u32(unconst_u32(561))][u32(unconst_u32(53))][u32(unconst_u32(1))][2]; |
| let ptr6: ptr<storage, array<array<f16, 3>, 3>, read> = &buffer6[u32(unconst_u32(103))][0][u32(unconst_u32(39))]; |
| let ptr7: ptr<storage, f16, read> = &buffer6[arrayLength(&buffer6)][0][u32(unconst_u32(100))][u32(unconst_u32(138))][u32(unconst_u32(72))]; |
| (*a0)[u32(unconst_u32(115))] = T0(mat3x3f(f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]), f32((*ptr2)[u32(unconst_u32(241))][2]))); |
| out[u32(unconst_u32(428))] = vec2i(i32(buffer6[arrayLength(&buffer6)][0][u32(unconst_u32(119))][u32(unconst_u32(68))][2])); |
| let ptr8: ptr<storage, f16, read> = &(*ptr4)[u32(unconst_u32(153))][u32((*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(256))][2][u32((*&buffer6)[arrayLength(&(*&buffer6))][0][u32(unconst_u32(160))][2][2])][u32(unconst_u32(19))])]; |
| let ptr9: ptr<storage, f16, read> = &(*ptr0)[2]; |
| out[u32(unconst_u32(82))] ^= vec2i(i32(buffer6[u32(unconst_u32(36))][u32(unconst_u32(132))][u32(unconst_u32(81))][u32(unconst_u32(215))][2])); |
| let ptr10: ptr<storage, array<array<f16, 3>, 3>, read> = &buffer6[arrayLength(&buffer6)][0][u32(unconst_u32(340))]; |
| let ptr11: ptr<storage, array<array<f16, 3>, 3>, read> = &buffer6[u32(unconst_u32(48))][u32(unconst_u32(23))][u32(unconst_u32(89))]; |
| let ptr12: ptr<storage, f16, read> = &buffer6[u32(unconst_u32(111))][0][u32((*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(382))][2][2][2])][u32(unconst_u32(231))][u32((*ptr2)[u32(unconst_u32(132))][u32(unconst_u32(103))])]; |
| out[u32(unconst_u32(54))] = vec2i(i32((*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(15))][u32(unconst_u32(9))][u32(unconst_u32(12))][2])); |
| let ptr13: ptr<storage, array<array<f16, 3>, 3>, read> = &buffer6[arrayLength(&buffer6)][0][u32(unconst_u32(108))]; |
| return out; |
| _ = buffer6; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentOutput0 { |
| @location(0) f0: vec4i, |
| @location(7) @interpolate(flat) f1: vec4u, |
| } |
| |
| struct T0 { |
| @size(64) f0: mat3x3f, |
| } |
| |
| struct VertexOutput0 { |
| @builtin(position) f0: vec4f, |
| } |
| |
| @group(0) @binding(8) var<storage, read> buffer6: array<array<array<array<array<f16, 3>, 3>, 3>, 1>>; |
| |
| @vertex |
| fn vertex0() -> VertexOutput0 { |
| var out: VertexOutput0; |
| let ptr16: ptr<storage, f16, read> = &buffer6[arrayLength(&buffer6)][0][2][u32(unconst_u32(15))][2]; |
| return out; |
| _ = buffer6; |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| let ptr17: ptr<storage, array<f16, 3>, read> = &buffer6[u32(unconst_u32(350))][0][2][2]; |
| out.f0 ^= vec4i(i32(buffer6[arrayLength(&buffer6)][0][2][u32(unconst_u32(404))][u32((*&buffer6)[arrayLength(&(*&buffer6))][0][u32(unconst_u32(16))][u32(unconst_u32(594))][u32(unconst_u32(225))])])); |
| var vf0 = fn1(); |
| let ptr18: ptr<storage, f16, read> = &buffer6[arrayLength(&buffer6)][u32(unconst_u32(167))][2][2][u32(unconst_u32(70))]; |
| vf0.f0 = vec4f(f32(buffer6[arrayLength(&buffer6)][0][2][2][2])); |
| let ptr19: ptr<storage, array<array<f16, 3>, 3>, read> = &(*&buffer6)[u32(unconst_u32(67))][0][u32(unconst_u32(127))]; |
| var vf1: vec4h = sin(vec4h(unconst_f16(6717.9), unconst_f16(5768.4), unconst_f16(10341.8), unconst_f16(17517.4))); |
| out = FragmentOutput0(vec4i(i32((*&buffer6)[u32(unconst_u32(64))][u32(unconst_u32(14))][2][2][2])), unpack4xU8(u32((*&buffer6)[u32(unconst_u32(64))][u32(unconst_u32(14))][2][2][2]))); |
| vf1 = vec4h((*&buffer6)[arrayLength(&(*&buffer6))][0][u32(unconst_u32(130))][u32(unconst_u32(287))][2]); |
| vf0.f0 *= vec4f(f32((*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(17))][2][2][u32(unconst_u32(135))])); |
| let ptr20: ptr<storage, f16, read> = &(*&buffer6)[arrayLength(&(*&buffer6))][0][u32(unconst_u32(225))][2][2]; |
| let ptr21: ptr<storage, array<f16, 3>, read> = &buffer6[arrayLength(&buffer6)][u32(unconst_u32(586))][2][2]; |
| let ptr22: ptr<storage, array<f16, 3>, read> = &(*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(68))][2][u32(unconst_u32(666))]; |
| fn1(); |
| return out; |
| _ = buffer6; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| let ptr23: ptr<storage, array<array<array<array<f16, 3>, 3>, 3>, 1>, read> = &(*&buffer6)[arrayLength(&(*&buffer6)) - 1]; |
| let ptr24: ptr<storage, f16, read> = &(*&buffer6)[arrayLength(&(*&buffer6))][u32(unconst_u32(318))][u32(unconst_u32(468))][2][2]; |
| vw0 -= vec4f(f32((*ptr23)[0][u32(unconst_u32(176))][u32(unconst_u32(322))][2])); |
| _ = buffer6; |
| }`, |
| }); |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 2304}}], |
| }); |
| let buffer7 = device0.createBuffer({ |
| size: 5114, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture11 = device0.createTexture({ |
| size: [60, 20, 73], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView6 = texture10.createView({}); |
| let sampler9 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 88.43, compare: 'greater'}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup1, new Uint32Array(1822), 336, 0); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer7, offset: 0, size: 320}}], |
| }); |
| let computePassEncoder11 = commandEncoder11.beginComputePass({}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup1, new Uint32Array(1382), 132, 0); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer7, offset: 1024, size: 388}}], |
| }); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let computePassEncoder12 = commandEncoder12.beginComputePass({}); |
| let sampler10 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.20, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 192 */ |
| offset: 192, |
| bytesPerRow: 15360, |
| buffer: buffer4, |
| }, { |
| texture: texture3, |
| mipLevel: 1, |
| origin: {x: 2, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 12, new Float32Array(30746), 7920, 4); |
| } catch {} |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 53, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 1280, size: 4124}}], |
| }); |
| let textureView7 = texture9.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| let computePassEncoder13 = commandEncoder13.beginComputePass({}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(43), 2, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 2200, new Float32Array(39480), 5373, 80); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 53, resource: {buffer: buffer7, offset: 512, size: 20}}], |
| }); |
| let externalTexture1 = device0.importExternalTexture({label: '\u0f07\u{1fa07}', source: videoFrame0}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let textureView8 = texture10.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder14 = commandEncoder14.beginComputePass({}); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup7, new Uint32Array(1941), 310, 0); |
| } catch {} |
| try { |
| await buffer1.mapAsync(GPUMapMode.WRITE, 0, 84); |
| } catch {} |
| let buffer8 = device0.createBuffer({ |
| size: 2549, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup7, new Uint32Array(1077), 363, 0); |
| } catch {} |
| let buffer9 = device0.createBuffer({ |
| size: 8215, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let sampler11 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 82.18}); |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToBuffer({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'depth-only', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3232 */ |
| offset: 3232, |
| buffer: buffer0, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let imageBitmap0 = await createImageBitmap(videoFrame0); |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| requires unrestricted_pointer_parameters; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw5: atomic<i32>; |
| |
| @group(0) @binding(8) var<storage, read> buffer10: array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 27>>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw3: array<atomic<i32>, 6>; |
| |
| struct FragmentOutput1 { |
| @builtin(frag_depth) f0: f32, |
| @location(0) @interpolate(flat, centroid) f1: vec4i, |
| } |
| |
| var<workgroup> vw6: mat2x2h; |
| |
| struct T0 { |
| @size(56) f0: array<u32>, |
| } |
| |
| var<workgroup> vw2: array<array<vec4<bool>, 1>, 1>; |
| |
| var<workgroup> vw4: FragmentOutput1; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @fragment |
| fn fragment1() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let ptr25: ptr<storage, array<f16, 1>, read> = &(*&buffer10)[u32(unconst_u32(346))][u32(unconst_u32(220))][u32(unconst_u32(77))][0][u32(unconst_u32(91))]; |
| let ptr26: ptr<storage, array<f16, 1>, read> = &buffer10[arrayLength(&buffer10)][u32(unconst_u32(163))][u32(unconst_u32(550))][u32(unconst_u32(222))][u32(unconst_u32(617))]; |
| let ptr27: ptr<storage, f16, read> = &buffer10[arrayLength(&buffer10)][u32(unconst_u32(52))][0][0][0][0]; |
| out.f0 = f32((*&buffer10)[arrayLength(&(*&buffer10))][26][0][0][0][0]); |
| let ptr28: ptr<storage, array<f16, 1>, read> = &buffer10[arrayLength(&buffer10)][u32(unconst_u32(122))][0][u32(unconst_u32(686))][u32(unconst_u32(52))]; |
| out.f0 *= f32((*&buffer10)[arrayLength(&(*&buffer10))][26][u32(unconst_u32(300))][0][0][0]); |
| let ptr29: ptr<storage, array<f16, 1>, read> = &buffer10[u32(unconst_u32(50))][u32(unconst_u32(26))][0][u32(unconst_u32(162))][0]; |
| let ptr30: ptr<storage, f16, read> = &buffer10[u32(unconst_u32(283))][26][0][0][u32(unconst_u32(24))][u32(unconst_u32(12))]; |
| out.f0 = f32((*&buffer10)[arrayLength(&(*&buffer10))][u32(unconst_u32(81))][0][0][0][0]); |
| out.f0 = f32((*&buffer10)[u32(unconst_u32(258))][26][u32(unconst_u32(52))][0][0][0]); |
| let ptr31: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 27>, read> = &buffer10[u32(unconst_u32(25))]; |
| discard; |
| let ptr32: ptr<storage, f16, read> = &buffer10[u32((*&buffer10)[arrayLength(&(*&buffer10))][u32(unconst_u32(69))][0][0][u32(unconst_u32(48))][u32(unconst_u32(396))])][u32(unconst_u32(32))][u32(unconst_u32(284))][u32(unconst_u32(166))][u32(unconst_u32(60))][0]; |
| let ptr33: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer10[u32(unconst_u32(36))][26][u32(unconst_u32(197))]; |
| let ptr34: ptr<storage, f16, read> = &(*&buffer10)[arrayLength(&(*&buffer10))][u32(unconst_u32(49))][0][0][0][0]; |
| out.f0 -= f32((*&buffer10)[arrayLength(&(*&buffer10))][u32((*&buffer10)[arrayLength(&(*&buffer10))][u32(unconst_u32(269))][u32(unconst_u32(50))][u32(unconst_u32(349))][0][u32(unconst_u32(86))])][0][0][u32(unconst_u32(200))][u32(buffer10[u32(unconst_u32(551))][u32(unconst_u32(38))][u32(unconst_u32(188))][u32(unconst_u32(31))][u32(unconst_u32(76))][0])]); |
| return out; |
| _ = buffer10; |
| } |
| |
| @compute @workgroup_size(5, 2, 1) |
| fn compute1() { |
| let ptr35: ptr<storage, array<f16, 1>, read> = &(*&buffer10)[u32(unconst_u32(196))][u32(unconst_u32(100))][0][u32(unconst_u32(145))][u32(unconst_u32(402))]; |
| let vf2: bool = (*&vw2)[0][0][u32(buffer10[arrayLength(&buffer10)][u32(unconst_u32(219))][0][0][0][u32(unconst_u32(680))])]; |
| let ptr36: ptr<storage, array<f16, 1>, read> = &(*&buffer10)[u32(unconst_u32(76))][26][0][0][0]; |
| vw4.f1 = vec4i(i32(buffer10[arrayLength(&buffer10)][26][u32(unconst_u32(515))][u32(unconst_u32(61))][u32(unconst_u32(12))][0])); |
| let ptr37: ptr<storage, f16, read> = &(*&buffer10)[arrayLength(&(*&buffer10))][u32(unconst_u32(291))][u32(unconst_u32(173))][u32(unconst_u32(108))][0][u32((*&buffer10)[u32(unconst_u32(154))][26][0][u32(unconst_u32(109))][0][0])]; |
| let ptr38: ptr<workgroup, array<array<vec4<bool>, 1>, 1>> = &vw2; |
| atomicAnd(&vw5, i32(unconst_i32(270))); |
| let ptr39: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 27>, read> = &(*&buffer10)[u32(unconst_u32(261))]; |
| let ptr40: ptr<storage, f16, read> = &buffer10[u32(unconst_u32(307))][u32(unconst_u32(47))][0][u32(unconst_u32(194))][0][0]; |
| var vf3: i32 = atomicExchange(&(*&vw3)[5], i32(unconst_i32(1))); |
| let ptr41: ptr<storage, array<f16, 1>, read> = &buffer10[u32(unconst_u32(27))][u32(unconst_u32(196))][u32(unconst_u32(301))][0][0]; |
| let ptr42: ptr<storage, array<f16, 1>, read> = &buffer10[arrayLength(&buffer10)][u32(unconst_u32(346))][0][0][u32(buffer10[u32(any(vw2[0][u32(unconst_u32(219))]))][u32(unconst_u32(329))][u32((*&buffer10)[arrayLength(&(*&buffer10))][26][u32(unconst_u32(127))][u32(unconst_u32(167))][0][0])][u32(unconst_u32(138))][u32(unconst_u32(678))][0])]; |
| atomicAnd(&vw5, i32(unconst_i32(205))); |
| vw2[u32(unconst_u32(93))][u32(unconst_u32(192))] = vec4<bool>(bool(buffer10[arrayLength(&buffer10)][26][0][0][u32(unconst_u32(23))][0])); |
| let ptr43: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 27>, read> = &(*&buffer10)[i32(unconst_i32(40))]; |
| _ = buffer10; |
| }`, |
| }); |
| let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(0); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 53, resource: {buffer: buffer8, offset: 1024, size: 64}}], |
| }); |
| let texture12 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 77}, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView9 = texture0.createView({baseArrayLayer: 1, arrayLayerCount: 3}); |
| let computePassEncoder15 = commandEncoder15.beginComputePass(); |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup5, new Uint32Array(948), 125, 0); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder2.popDebugGroup(); |
| } catch {} |
| let pipeline1 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'greater-equal', |
| depthBias: -1938757720, |
| depthBiasClamp: 510.4241458041224, |
| }, |
| vertex: {module: shaderModule0, buffers: []}, |
| }); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let texture13 = device0.createTexture({ |
| size: [240, 80, 1], |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture14 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView10 = texture0.createView({dimension: '2d', aspect: 'all'}); |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 8, resource: {buffer: buffer5, offset: 5376, size: 156}}], |
| }); |
| let buffer11 = device0.createBuffer({ |
| size: 6398, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let sampler12 = device0.createSampler({}); |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt2020', transfer: 'iec6196624'} }); |
| let autogeneratedBindGroupLayout1 = pipeline0.getBindGroupLayout(0); |
| let texture15 = device0.createTexture({ |
| size: [30, 10, 1], |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let computePassEncoder16 = commandEncoder17.beginComputePass({}); |
| let sampler13 = device0.createSampler({ |
| label: '\u{1fe80}\uce85\u07a1\ufef1\ud1cd', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 71.36, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup8, new Uint32Array(39), 18, 0); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| let imageData2 = new ImageData(20, 72); |
| try { |
| adapter0.label = '\u0605\u0d32\u2a41'; |
| } catch {} |
| let textureView11 = texture7.createView({dimension: '2d', aspect: 'depth-only'}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup4); |
| } catch {} |
| let buffer12 = device0.createBuffer({ |
| size: 20327, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({size: [30, 10, 1], format: 'depth32float', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder17 = commandEncoder18.beginComputePass(); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 0, y: 4, z: 8}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 796 */ |
| offset: 796, |
| bytesPerRow: 1024, |
| rowsPerImage: 1574, |
| buffer: buffer4, |
| }, {width: 7, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 1, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(22).fill(52), /* required buffer size: 22 */ |
| {offset: 22, bytesPerRow: 111}, {width: 10, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData3 = new ImageData(80, 32); |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer7, offset: 0, size: 1244}}, |
| {binding: 258, resource: textureView10}, |
| ], |
| }); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer11, 492, buffer0, 792, 148); |
| } catch {} |
| try { |
| commandEncoder19.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 2, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout2 = pipeline1.getBindGroupLayout(0); |
| let buffer13 = device0.createBuffer({size: 34641, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let textureView12 = texture11.createView({}); |
| let renderPassEncoder0 = commandEncoder16.beginRenderPass({ |
| label: 'a', |
| colorAttachments: [{view: textureView12, depthSlice: 35, loadOp: 'clear', storeOp: 'discard'}], |
| depthStencilAttachment: {view: textureView2, depthClearValue: -7.957212059547041, depthReadOnly: true, stencilClearValue: 22320}, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup4, new Uint32Array(1433), 66, 0); |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder19.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3488 */ |
| offset: 3488, |
| buffer: buffer12, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder19.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'depth-only', |
| }, { |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1992 */ |
| offset: 1992, |
| bytesPerRow: 18176, |
| buffer: buffer13, |
| }, {width: 3, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0); |
| let renderPassEncoder1 = commandEncoder19.beginRenderPass({ |
| label: 'b', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 15, |
| clearValue: { r: -505.9, g: 535.7, b: 413.6, a: 862.2, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView2, depthReadOnly: true, stencilClearValue: 13577}, |
| occlusionQuerySet: querySet0, |
| }); |
| let sampler14 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'not-equal', |
| }); |
| try { |
| renderPassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer8, 344); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer11, 1068, buffer2, 16, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 644, new BigUint64Array(13976), 5809, 136); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(32).fill(4), /* required buffer size: 32 */ |
| {offset: 32}, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer0 = commandEncoder16.finish(); |
| let texture17 = device0.createTexture({ |
| size: [120, 40, 147], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler15 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.19, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup8, new Uint32Array(5703), 1_320, 0); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(6, buffer9); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 508, new DataView(new ArrayBuffer(8854)), 599, 1120); |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout4 = pipeline0.getBindGroupLayout(0); |
| let texture18 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| mipLevelCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView13 = texture3.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup8, new Uint32Array(1306), 7, 0); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder(); |
| let texture19 = device0.createTexture({ |
| size: [60, 20, 55], |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView14 = texture15.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup8, new Uint32Array(234), 5, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(207).fill(97), /* required buffer size: 207 */ |
| {offset: 207}, {width: 60, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView15 = texture13.createView({mipLevelCount: 1}); |
| let computePassEncoder18 = commandEncoder20.beginComputePass({}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 152, new Float32Array(5469), 1789, 28); |
| } catch {} |
| try { |
| globalThis.someLabel = renderBundle1.label; |
| } catch {} |
| let autogeneratedBindGroupLayout5 = pipeline0.getBindGroupLayout(0); |
| let bindGroup11 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer7, offset: 512, size: 96}}], |
| }); |
| let buffer14 = device0.createBuffer({ |
| size: 2105, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let texture20 = device0.createTexture({ |
| size: [30], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'greater-equal', |
| maxAnisotropy: 10, |
| }); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup8, new Uint32Array(1394), 120, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(97); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer9, 'uint32', 200, 1_256); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer9, 0, 257); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToBuffer(buffer14, 1456, buffer13, 752, 288); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 8, resource: {buffer: buffer14, offset: 0, size: 80}}], |
| }); |
| let buffer15 = device0.createBuffer({ |
| size: 64775, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture21 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 42}, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.79, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| let texture22 = device0.createTexture({ |
| size: [30, 10, 29], |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView16 = texture1.createView({dimension: '2d-array', aspect: 'stencil-only', baseMipLevel: 0}); |
| let computePassEncoder19 = commandEncoder21.beginComputePass({}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let renderBundle2 = renderBundleEncoder2.finish({}); |
| let sampler18 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 9, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer4, 232); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(147); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle2, renderBundle2]); |
| } catch {} |
| let arrayBuffer0 = buffer1.getMappedRange(8, 20); |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let textureView17 = texture8.createView({dimension: '2d-array', aspect: 'depth-only', baseArrayLayer: 8, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup5, new Uint32Array(2440), 416, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer9, 'uint32', 2_288, 214); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer11, 2_820, 81); |
| } catch {} |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1956 */ |
| offset: 1956, |
| buffer: buffer12, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder22.resolveQuerySet(querySet0, 332, 200, buffer5, 3584); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let buffer16 = device0.createBuffer({size: 6308, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture23 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 96}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder20 = commandEncoder22.beginComputePass({}); |
| let sampler19 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 88.60}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup1, new Uint32Array(608), 359, 0); |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1, renderBundle2, renderBundle1, renderBundle2]); |
| } catch {} |
| try { |
| texture18.destroy(); |
| } catch {} |
| let autogeneratedBindGroupLayout6 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let commandBuffer1 = commandEncoder23.finish({}); |
| let texture24 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 34}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBlendConstant({ r: -687.4, g: 428.5, b: -91.33, a: -805.4, }); |
| } catch {} |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let textureView18 = texture23.createView({baseMipLevel: 0, baseArrayLayer: 46, arrayLayerCount: 1}); |
| let textureView19 = texture21.createView({aspect: 'depth-only', baseArrayLayer: 9, arrayLayerCount: 10}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup9, new Uint32Array(4753), 502, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup4, new Uint32Array(781), 62, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer11, 0, 1_358); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToBuffer(buffer12, 1440, buffer4, 3592, 44); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 5, y: 2, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(101).fill(237), /* required buffer size: 101 */ |
| {offset: 101, rowsPerImage: 42}, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 8, resource: {buffer: buffer7, offset: 512, size: 776}}], |
| }); |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| let computePassEncoder21 = commandEncoder24.beginComputePass({}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup8, new Uint32Array(2367), 220, 0); |
| } catch {} |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup5, new Uint32Array(679), 20, 0); |
| } catch {} |
| let buffer17 = device0.createBuffer({ |
| size: 6364, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let computePassEncoder22 = commandEncoder17.beginComputePass(); |
| let sampler20 = device0.createSampler({addressModeU: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 91.83}); |
| try { |
| computePassEncoder22.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer17, 0, 265); |
| } catch {} |
| try { |
| buffer2.label = '\u{1ff4d}\ua4ae\u{1fe7c}\u0865\ua1fd\ue6e6\u65da\ub24d\u{1f8ff}'; |
| } catch {} |
| let buffer18 = device0.createBuffer({size: 4584, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder27 = device0.createCommandEncoder({label: '\u3940\u197b\ucbac\uf18d\ued07\uaf68\udbae\u087e\u0c8b\u106f'}); |
| let texture25 = device0.createTexture({ |
| size: [120, 40, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder23 = commandEncoder25.beginComputePass({}); |
| let renderPassEncoder2 = commandEncoder26.beginRenderPass({ |
| label: 'c', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 9, |
| clearValue: { r: -944.2, g: 92.63, b: -522.4, a: -534.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView2, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilClearValue: 21370, |
| }, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup1, new Uint32Array(1259), 94, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer8, 'uint16', 8, 2_029); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 30 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 340 */ |
| offset: 340, |
| bytesPerRow: 19968, |
| buffer: buffer4, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let texture26 = device0.createTexture({ |
| size: [120, 40, 99], |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder24 = commandEncoder27.beginComputePass({}); |
| let renderPassEncoder3 = commandEncoder28.beginRenderPass({ |
| label: 'd', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 56, |
| clearValue: { r: -593.2, g: 338.0, b: 117.8, a: 414.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView2, depthLoadOp: 'load', depthStoreOp: 'discard', depthReadOnly: false}, |
| }); |
| try { |
| renderPassEncoder2.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 1_074, 461); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder3.insertDebugMarker('\u2b49'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let textureView20 = texture26.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 11}); |
| try { |
| device0.queue.writeBuffer(buffer4, 3376, new Int16Array(5887), 1156, 524); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let computePassEncoder25 = commandEncoder29.beginComputePass(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 396, resource: {buffer: buffer17, offset: 256}}], |
| }); |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let computePassEncoder26 = commandEncoder30.beginComputePass({}); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer9, 'uint16', 1_430, 150); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline2 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| let autogeneratedBindGroupLayout7 = pipeline1.getBindGroupLayout(0); |
| let buffer19 = device0.createBuffer({ |
| size: 11000, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder23.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup9); |
| } catch {} |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let renderPassEncoder4 = commandEncoder31.beginRenderPass({ |
| label: 'f', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 56, |
| clearValue: { r: 710.1, g: 454.0, b: 942.3, a: 841.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView2, |
| depthClearValue: 0.45780801017292794, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'store', |
| stencilClearValue: 47208, |
| }, |
| }); |
| let sampler21 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 80.23}); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup1, new Uint32Array(105), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(142); |
| } catch {} |
| let textureView21 = texture23.createView({mipLevelCount: 1, baseArrayLayer: 38, arrayLayerCount: 13}); |
| let textureView22 = texture5.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer12, 6_688); }; |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer9, 'uint32', 360, 1_318); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer19, offset: 3072, size: 1356}}, |
| {binding: 258, resource: textureView0}, |
| ], |
| }); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let textureView23 = texture4.createView({aspect: 'depth-only', format: 'depth32float', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1500 */ |
| offset: 1500, |
| bytesPerRow: 29696, |
| buffer: buffer16, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData4 = new ImageData(4, 20); |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 159, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 256, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 290, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let computePassEncoder27 = commandEncoder32.beginComputePass({}); |
| try { |
| computePassEncoder17.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup7, new Uint32Array(408), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer8, 'uint16', 218, 216); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 8, resource: {buffer: buffer7, offset: 1536, size: 780}}], |
| }); |
| let commandEncoder33 = device0.createCommandEncoder(); |
| let texture27 = device0.createTexture({ |
| size: [30, 10, 1], |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder28 = commandEncoder33.beginComputePass({}); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup7, new Uint32Array(367), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer8, 'uint32', 492, 1_899); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 348, new Float32Array(6097), 1159, 428); |
| } catch {} |
| let texture28 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture29 = device0.createTexture({ |
| size: [60], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup13, new Uint32Array(77), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer8, 'uint16', 422, 629); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer9); |
| } catch {} |
| try { |
| buffer17.unmap(); |
| } catch {} |
| await gc(); |
| let buffer20 = device0.createBuffer({ |
| size: 6203, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView24 = texture28.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 11.62, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(463), 12, 0); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| let autogeneratedBindGroupLayout8 = pipeline0.getBindGroupLayout(0); |
| let textureView25 = texture16.createView({}); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup15, new Uint32Array(867), 51, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout9 = pipeline1.getBindGroupLayout(0); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| let sampler23 = device0.createSampler({ |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup16, new Uint32Array(3278), 993, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder14.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup4, new Uint32Array(2527), 420, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer17, 696); |
| } catch {} |
| let texture30 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder29 = commandEncoder14.beginComputePass(); |
| try { |
| computePassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, buffer7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer8, 'uint16', 56, 319); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 0, y: 21, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(47).fill(245), /* required buffer size: 47 */ |
| {offset: 47}, {width: 40, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture31 = device0.createTexture({ |
| size: [240, 80, 1], |
| mipLevelCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup10, new Uint32Array(1562), 33, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer4); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer11, 0, 1_527); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder15.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 396 */ |
| offset: 376, |
| buffer: buffer3, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 6, y: 1, z: 3}, |
| aspect: 'all', |
| }, {width: 5, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture30, |
| mipLevel: 2, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 1, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer2 = commandEncoder15.finish(); |
| let sampler24 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 91.03}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup13, new Uint32Array(297), 42, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer9, 'uint16', 2_578, 1_983); |
| } catch {} |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout5]}); |
| let buffer21 = device0.createBuffer({ |
| size: 14119, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let texture32 = device0.createTexture({ |
| size: [240, 80, 1], |
| mipLevelCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder5 = commandEncoder34.beginRenderPass({ |
| label: 'g', |
| colorAttachments: [{view: textureView13, loadOp: 'load', storeOp: 'discard'}], |
| depthStencilAttachment: {view: textureView20, depthClearValue: 0.20025147634243212, depthLoadOp: 'clear', depthStoreOp: 'store'}, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer8, 'uint32', 612, 1_170); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer8, 'uint16', 96, 557); |
| } catch {} |
| try { |
| adapter0.label = '\u{1f9a3}\ua56a\u0a3b\u3de2\u83d5\u0a22\u{1fad8}\ueedc'; |
| } catch {} |
| let autogeneratedBindGroupLayout10 = pipeline1.getBindGroupLayout(0); |
| let bindGroup17 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer7, offset: 1792, size: 448}}], |
| }); |
| let sampler25 = device0.createSampler({addressModeW: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 1_080, 824); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer8, 'uint16', 788, 577); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer4, 2_996, 189); |
| } catch {} |
| let buffer22 = device0.createBuffer({ |
| size: 35318, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture33 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 34}, |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup17, new Uint32Array(259), 121, 0); |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup12, new Uint32Array(3199), 269, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle2, renderBundle2, renderBundle0, renderBundle2]); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer22, 'uint16', 4_558, 1_511); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let computePassEncoder30 = commandEncoder35.beginComputePass({}); |
| let sampler26 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 6.060, |
| lodMaxClamp: 80.58, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup15, new Uint32Array(1842), 141, 0); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer21, 'uint16', 1_218, 1_200); |
| } catch {} |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| let pipeline3 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.GREEN}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilFront: {}, |
| stencilWriteMask: 1677114679, |
| depthBias: -1874332198, |
| }, |
| vertex: {module: shaderModule0, entryPoint: 'vertex0', constants: {}, buffers: []}, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'front'}, |
| }); |
| let autogeneratedBindGroupLayout11 = pipeline2.getBindGroupLayout(0); |
| let bindGroup18 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 1024}}], |
| }); |
| let commandEncoder36 = device0.createCommandEncoder(); |
| let computePassEncoder31 = commandEncoder36.beginComputePass(); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup1, new Uint32Array(3743), 185, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer9, 'uint16', 166, 1_722); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer11); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout8, |
| entries: [{binding: 8, resource: {buffer: buffer15, offset: 11520, size: 18764}}], |
| }); |
| let buffer23 = device0.createBuffer({ |
| size: 3579, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let renderBundle3 = renderBundleEncoder3.finish({}); |
| let sampler27 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 404, 453); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(6, buffer20, 1_600); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 1, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(10_280).fill(94), /* required buffer size: 10_280 */ |
| {offset: 179, bytesPerRow: 39, rowsPerImage: 37}, {width: 0, height: 0, depthOrArrayLayers: 8}); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout12 = pipeline3.getBindGroupLayout(0); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout12, |
| entries: [{binding: 8, resource: {buffer: buffer8, offset: 0, size: 304}}], |
| }); |
| let texture34 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture35 = device0.createTexture({ |
| size: [30, 10, 1], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler28 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 51.62}); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline3); |
| } catch {} |
| let texture36 = device0.createTexture({ |
| size: [60, 20, 20], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder28.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setStencilReference(111); |
| } catch {} |
| let textureView26 = texture24.createView({format: 'r32uint', baseArrayLayer: 2, arrayLayerCount: 6}); |
| let texture37 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView27 = texture35.createView({format: 'rgba8sint'}); |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer20, 964, 475); |
| } catch {} |
| try { |
| await promise1; |
| } catch {} |
| let textureView28 = texture34.createView({}); |
| let textureView29 = texture0.createView({mipLevelCount: 1, arrayLayerCount: 7}); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 86.14, |
| }); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup19, new Uint32Array(1501), 1_051, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup16); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 54, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup21 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 512}}], |
| }); |
| let commandEncoder37 = device0.createCommandEncoder({}); |
| let computePassEncoder32 = commandEncoder37.beginComputePass(); |
| let sampler30 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.98, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup4, []); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 1, y: 10, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(52_555).fill(90), /* required buffer size: 52_555 */ |
| {offset: 80, bytesPerRow: 193, rowsPerImage: 15}, {width: 43, height: 2, depthOrArrayLayers: 19}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 53, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup16, new Uint32Array(705), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup9, new Uint32Array(424), 74, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer20, 3_708); |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 396, resource: {buffer: buffer22, offset: 3072, size: 7164}}], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup19, new Uint32Array(993), 338, 0); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline0); |
| } catch {} |
| let imageData5 = new ImageData(52, 8); |
| let texture38 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 23}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup4, new Uint32Array(205), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setStencilReference(2272); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(5, buffer8, 740, 100); |
| } catch {} |
| let videoFrame2 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [{binding: 53, resource: {buffer: buffer7, offset: 256, size: 1184}}], |
| }); |
| let textureView30 = texture36.createView({label: '\u03fb\ue2a2\u2542\u3f9e', dimension: '2d'}); |
| let texture39 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 25}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup5, new Uint32Array(296), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle1, renderBundle1]); |
| } catch {} |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup19, new Uint32Array(754), 75, 0); |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(54); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| let autogeneratedBindGroupLayout13 = pipeline0.getBindGroupLayout(0); |
| let buffer24 = device0.createBuffer({ |
| size: 48228, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let sampler31 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 84.14, maxAnisotropy: 1}); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup4, []); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup4, new Uint32Array(1752), 690, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| renderPassEncoder3.insertDebugMarker('\u166a'); |
| } catch {} |
| let autogeneratedBindGroupLayout14 = pipeline2.getBindGroupLayout(0); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 1536, size: 3840}}], |
| }); |
| let commandEncoder38 = device0.createCommandEncoder({}); |
| let renderPassEncoder6 = commandEncoder38.beginRenderPass({ |
| label: 'h', |
| colorAttachments: [{ |
| view: textureView30, |
| clearValue: { r: -470.5, g: 628.0, b: 271.7, a: -562.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView23, depthClearValue: 8.868418674524861, depthReadOnly: true, stencilClearValue: 42380}, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup19, new Uint32Array(4388), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.end(); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle1]); |
| } catch {} |
| let buffer25 = device0.createBuffer({size: 10513, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let textureView31 = texture38.createView({mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 10}); |
| let textureView32 = texture8.createView({aspect: 'depth-only', baseArrayLayer: 1, arrayLayerCount: 2}); |
| let sampler32 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.90, |
| compare: 'not-equal', |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup8, new Uint32Array(2910), 263, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer22, 'uint32', 16_720, 349); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(5, buffer24); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 76 */ |
| offset: 76, |
| bytesPerRow: 35584, |
| buffer: buffer4, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(130).fill(195), /* required buffer size: 130 */ |
| {offset: 130, rowsPerImage: 9}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup25 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout7, |
| entries: [{binding: 8, resource: {buffer: buffer5, offset: 0, size: 2024}}], |
| }); |
| let commandBuffer3 = commandEncoder31.finish(); |
| let texture40 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder33 = commandEncoder39.beginComputePass({}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| let renderBundle4 = renderBundleEncoder4.finish({}); |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer8, 280); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 3892, new DataView(new ArrayBuffer(6246)), 522); |
| } catch {} |
| let buffer26 = device0.createBuffer({ |
| size: 6908, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let texture41 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 37}, |
| mipLevelCount: 3, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler33 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 90.68, |
| compare: 'greater', |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setScissorRect(7, 3, 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder40.copyBufferToTexture({ |
| /* bytesInLastRow: 30 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2584 */ |
| offset: 2584, |
| bytesPerRow: 1792, |
| rowsPerImage: 11, |
| buffer: buffer18, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup26 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 396, resource: {buffer: buffer22, offset: 1024, size: 4464}}], |
| }); |
| let textureView33 = texture18.createView({aspect: 'all', arrayLayerCount: 3}); |
| let texture42 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8sint'], |
| }); |
| let computePassEncoder34 = commandEncoder40.beginComputePass({}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup6, []); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder5.setViewport(67.75197692782436, 26.237899403912298, 37.49454790998372, 9.707723618525664, 0.3112863064078085, 0.6639444916707524); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(5, buffer26, 128, 798); |
| } catch {} |
| let promise2 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'less-equal', |
| stencilReadMask: 288354875, |
| depthBias: -2092405046, |
| depthBiasSlopeScale: 0.0, |
| depthBiasClamp: 431.3224277131393, |
| }, |
| vertex: {module: shaderModule0, constants: {}, buffers: []}, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 994}); |
| let computePassEncoder35 = commandEncoder41.beginComputePass({}); |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 47.69, |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder35.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer24, 'uint32', 30_912, 4_468); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 46, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(12_953).fill(146), /* required buffer size: 12_953 */ |
| {offset: 349, bytesPerRow: 37, rowsPerImage: 48}, {width: 6, height: 5, depthOrArrayLayers: 8}); |
| } catch {} |
| try { |
| adapter0.label = '\u097b\u{1fa71}\u0b85\u9479\u6ccf'; |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| let autogeneratedBindGroupLayout15 = pipeline1.getBindGroupLayout(0); |
| try { |
| computePassEncoder34.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup17, new Uint32Array(5517), 2_815, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout16 = pipeline3.getBindGroupLayout(0); |
| let texture43 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture44 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 11}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup8, new Uint32Array(519), 49, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer22, 'uint32', 8_472, 5_318); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer15, 0, 18_521); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(3).fill(113), /* required buffer size: 3 */ |
| {offset: 3, rowsPerImage: 2}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| label: '\u4c3b\u923c\u0293\u96ac\u5c9f\u{1f92e}\u066d\u{1f999}\u0102\u283d\u0120', |
| entries: [ |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup27 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 8, resource: {buffer: buffer5, offset: 768}}], |
| }); |
| let textureView34 = texture0.createView({label: '\u0949\u9d07\uacb3\u0801\uafa4\u{1febc}', dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture45 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle2, renderBundle3, renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer20, 2_160, 607); |
| } catch {} |
| let bindGroup28 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout12, |
| entries: [{binding: 8, resource: {buffer: buffer14, offset: 0, size: 344}}], |
| }); |
| let buffer27 = device0.createBuffer({size: 3674, usage: GPUBufferUsage.COPY_SRC}); |
| let textureView35 = texture8.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let sampler35 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.45, |
| compare: 'greater', |
| maxAnisotropy: 3, |
| }); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup15, new Uint32Array(3231), 1_116, 0); |
| } catch {} |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder3.setViewport(41.02018004529836, 16.479005016997647, 3.212884339934029, 2.8720927760273645, 0.3372997116099913, 0.8498705816479961); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer24, 'uint16', 12_138, 703); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 408, new DataView(new ArrayBuffer(8826)), 128, 48); |
| } catch {} |
| let pipeline4 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{ |
| format: 'rgba8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilFront: {failOp: 'keep'}, |
| stencilReadMask: 2244968803, |
| depthBias: -1968190902, |
| depthBiasSlopeScale: 989.0996092380556, |
| }, |
| vertex: {module: shaderModule0, entryPoint: 'vertex0', constants: {}, buffers: []}, |
| primitive: {topology: 'line-list', frontFace: 'cw'}, |
| }); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let texture46 = device0.createTexture({ |
| size: [120, 40, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder36 = commandEncoder43.beginComputePass({}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup12, new Uint32Array(2634), 99, 0); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer24, 0, 19_329); |
| } catch {} |
| try { |
| commandEncoder42.copyBufferToBuffer(buffer8, 56, buffer13, 4092, 40); |
| } catch {} |
| try { |
| commandEncoder42.copyBufferToTexture({ |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1320 */ |
| offset: 1320, |
| bytesPerRow: 2816, |
| rowsPerImage: 45, |
| buffer: buffer12, |
| }, { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 8, y: 2, z: 21}, |
| aspect: 'all', |
| }, {width: 13, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder42.copyTextureToBuffer({ |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 44, y: 13, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 452 widthInBlocks: 113 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 460 */ |
| offset: 460, |
| rowsPerImage: 243, |
| buffer: buffer4, |
| }, {width: 113, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\ud432\u2216\u0544\u{1ffb6}\u0500\ucf26\u03df'; |
| } catch {} |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let textureView36 = texture34.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer11, 656); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBlendConstant({ r: -947.4, g: -522.3, b: 249.4, a: -597.2, }); |
| } catch {} |
| try { |
| commandEncoder42.copyBufferToBuffer(buffer7, 140, buffer4, 740, 92); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 988 */ |
| offset: 988, |
| bytesPerRow: 1280, |
| buffer: buffer20, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer28 = device0.createBuffer({ |
| size: 4808, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup28, new Uint32Array(780), 53, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(158).fill(223), /* required buffer size: 158 */ |
| {offset: 158}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder45 = device0.createCommandEncoder(); |
| let computePassEncoder37 = commandEncoder44.beginComputePass(); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup9, new Uint32Array(1029), 98, 0); |
| } catch {} |
| try { |
| commandEncoder45.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1208 */ |
| offset: 1208, |
| bytesPerRow: 12288, |
| buffer: buffer14, |
| }, { |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(13).fill(125), /* required buffer size: 13 */ |
| {offset: 13, bytesPerRow: 13}, {width: 2, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture47 = device0.createTexture({ |
| size: [30, 10, 36], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder38 = commandEncoder45.beginComputePass(); |
| let renderPassEncoder7 = commandEncoder42.beginRenderPass({ |
| label: 'i', |
| colorAttachments: [{ |
| view: textureView30, |
| clearValue: { r: -168.3, g: 228.3, b: 891.7, a: -907.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView23, |
| depthClearValue: 2.4541465938260956, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| stencilClearValue: 61792, |
| }, |
| maxDrawCount: 38273243, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer28, 'uint16', 100, 816); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let textureView37 = texture47.createView({mipLevelCount: 1}); |
| let renderPassEncoder8 = commandEncoder46.beginRenderPass({ |
| label: 'j', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -143.0, g: -308.8, b: -405.3, a: -737.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView20, depthClearValue: 0.33271487320896775, depthLoadOp: 'clear', depthStoreOp: 'store'}, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup9, new Uint32Array(753), 242, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| let commandEncoder47 = device0.createCommandEncoder({}); |
| let sampler36 = device0.createSampler({addressModeV: 'mirror-repeat'}); |
| try { |
| computePassEncoder37.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup12, new Uint32Array(1192), 91, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer4, 0, 1_176); |
| } catch {} |
| let arrayBuffer1 = buffer1.getMappedRange(32, 0); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let commandEncoder48 = device0.createCommandEncoder({label: '\u{1fab7}\u2ff1\u0ec1\u01ce\ua7e2\ue91f\u{1f9bd}\u{1fc61}\u{1ff1b}\ua545'}); |
| let texture48 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle1]); |
| } catch {} |
| await gc(); |
| let commandEncoder49 = device0.createCommandEncoder(); |
| let textureView38 = texture28.createView({dimension: 'cube-array', baseArrayLayer: 4, arrayLayerCount: 6}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder22.end(); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1552 */ |
| offset: 1552, |
| buffer: buffer23, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder18.pushDebugGroup('\ud5fb'); |
| } catch {} |
| try { |
| computePassEncoder18.popDebugGroup(); |
| } catch {} |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup28, new Uint32Array(3761), 293, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToTexture({ |
| /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 416 */ |
| offset: 416, |
| bytesPerRow: 18688, |
| buffer: buffer20, |
| }, { |
| texture: texture22, |
| mipLevel: 1, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise3; |
| } catch {} |
| document.body.append(canvas0); |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| struct VertexOutput1 { |
| @builtin(position) f1: vec4f, |
| @location(13) @interpolate(flat) f2: vec2f, |
| @location(0) @interpolate(flat, centroid) f3: vec4h, |
| } |
| |
| var<workgroup> vw9: FragmentOutput2; |
| |
| var<workgroup> vw12: array<VertexOutput1, 1>; |
| |
| @id(29819) override override2: u32; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @id(32077) override override1: u32 = 33; |
| |
| struct T0 { |
| @align(16) @size(16) f0: atomic<i32>, |
| @align(16) @size(1056) f1: array<array<atomic<i32>, 2>>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(49292) override override3: u32; |
| |
| struct S0 { |
| @builtin(local_invocation_index) f0: u32, |
| } |
| |
| fn fn0(a0: ptr<function, mat2x4f>) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| (*a0) -= (*a0); |
| out = FragmentOutput2(vec4i(acosh(vec3h(unconst_f16(5325.3), unconst_f16(4320.3), unconst_f16(8099.0))).bbbb)); |
| let vf4: u32 = override3; |
| vp0 = pow(f16(unconst_f16(5005.2)), f16(unconst_f16(-24102.1))); |
| vp0 = f16(vp1.f2[u32(unconst_u32(260))]); |
| return out; |
| _ = override3; |
| } |
| |
| fn fn1(a0: array<mat2x2h, 1>) -> mat2x3f { |
| var out: mat2x3f; |
| vw9 = FragmentOutput2(vec4i((*&vw13))); |
| vw10.f2 += unpack2x16unorm(override4); |
| vw7 = S0(u32(vw12[0].f3.a)); |
| vw10 = VertexOutput1(unpack4x8snorm(reverseBits(u32(unconst_u32(34)))), unpack2x16snorm(reverseBits(u32(unconst_u32(34)))), vec4h(f16(reverseBits(u32(unconst_u32(34)))))); |
| vw13 = vec4h(f16((*&vw7).f0)); |
| vw10.f3 -= vp1.f3; |
| vp2.f0 *= (*&vw7).f0; |
| vw8 = S0(vec4u((*&vw12)[0].f1)[2]); |
| vw8 = S0(bitcast<vec2u>(vp1.f2).y); |
| vp0 += f16((*&vw12)[0].f2[u32(unconst_u32(48))]); |
| let ptr44: ptr<workgroup, vec4h> = &vw10.f3; |
| return out; |
| _ = override4; |
| } |
| |
| var<workgroup> vw10: VertexOutput1; |
| |
| var<workgroup> vw7: S0; |
| |
| var<workgroup> vw13: vec4h; |
| |
| override override4: u32; |
| |
| var<private> vp1: VertexOutput1 = VertexOutput1(); |
| |
| var<private> vp0: f16 = f16(6384.1); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw11: FragmentOutput2; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T1 { |
| f0: mat2x3h, |
| @size(1184) f1: array<vec2u>, |
| } |
| |
| override override0: u32; |
| |
| @group(0) @binding(216) var tex0: texture_cube_array<f32>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn fn2() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| return out; |
| } |
| |
| var<workgroup> vw8: S0; |
| |
| struct FragmentOutput2 { |
| @location(0) @interpolate(flat, sample) f0: vec4i, |
| } |
| |
| var<private> vp2: S0 = S0(u32(4)); |
| |
| @vertex |
| fn vertex1(@location(5) a0: vec2f, @location(14) a1: f16, @location(4) @interpolate(flat) a2: vec2f) -> VertexOutput1 { |
| var out: VertexOutput1; |
| vp0 *= radians(vec4h(unconst_f16(19133.4), unconst_f16(1432.2), unconst_f16(4639.1), unconst_f16(3278.8)))[3]; |
| let vf5: u32 = textureNumLevels(tex0); |
| let vf6: u32 = override2; |
| var vf7: f16 = vp1.f3[u32(unconst_u32(77))]; |
| let ptr45: ptr<private, vec4f> = &vp1.f1; |
| let ptr46: ptr<private, vec4f> = &vp1.f1; |
| let vf8: vec2f = a2; |
| out = VertexOutput1(mix(vec4f(unconst_f32(0.00054), unconst_f32(0.04568), unconst_f32(0.08450), unconst_f32(0.01121)), vec4f(unconst_f32(0.3550), unconst_f32(0.3115), unconst_f32(0.1461), unconst_f32(0.6961)), vec4f(unconst_f32(0.3184), unconst_f32(0.2893), unconst_f32(-0.4803), unconst_f32(0.6195))), mix(vec4f(unconst_f32(0.00054), unconst_f32(0.04568), unconst_f32(0.08450), unconst_f32(0.01121)), vec4f(unconst_f32(0.3550), unconst_f32(0.3115), unconst_f32(0.1461), unconst_f32(0.6961)), vec4f(unconst_f32(0.3184), unconst_f32(0.2893), unconst_f32(-0.4803), unconst_f32(0.6195))).ra, vec4h(mix(vec4f(unconst_f32(0.00054), unconst_f32(0.04568), unconst_f32(0.08450), unconst_f32(0.01121)), vec4f(unconst_f32(0.3550), unconst_f32(0.3115), unconst_f32(0.1461), unconst_f32(0.6961)), vec4f(unconst_f32(0.3184), unconst_f32(0.2893), unconst_f32(-0.4803), unconst_f32(0.6195))))); |
| let vf9: vec2h = mix(vec2h(unconst_f16(1104.9), unconst_f16(-5745.7)), vec2h(unconst_f16(5089.8), unconst_f16(1024.6)), f16(unconst_f16(6114.5))); |
| vp1.f3 = bitcast<vec4h>(vp1.f2); |
| let vf10: f32 = (*ptr46)[u32(unconst_u32(108))]; |
| return out; |
| _ = override2; |
| _ = tex0; |
| } |
| |
| @fragment |
| fn fragment2(@location(13) @interpolate(perspective) a0: vec2f, @location(0) @interpolate(linear) a1: vec4h) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| var vf11 = fn2(); |
| fn2(); |
| var vf12: vec4h = tanh(vec4h(unconst_f16(1475.6), unconst_f16(-8336.7), unconst_f16(10790.3), unconst_f16(12753.6))); |
| vp0 = f16(a0[u32(unconst_u32(162))]); |
| let vf13: vec2f = a0; |
| vf12 = vf12; |
| vp2.f0 *= vec4u(vp1.f3)[1]; |
| vp2.f0 ^= override2; |
| let ptr47: ptr<private, vec4f> = &vp1.f1; |
| var vf14 = fn2(); |
| vf14.f0 = vec4i(tanh(vec4h(unconst_f16(974.5), unconst_f16(97.87), unconst_f16(12857.8), unconst_f16(31858.5)))); |
| out = FragmentOutput2(bitcast<vec4i>(vp1.f1)); |
| var vf15: f32 = vp1.f2[u32(unconst_u32(281))]; |
| vp1 = VertexOutput1(vec4f(a1), bitcast<vec2f>(a1), a1); |
| var vf16: u32 = override3; |
| let vf17: f32 = step(f32(unconst_f32(0.2829)), f32(unconst_f32(-0.2386))); |
| let vf18: vec3h = sinh(vec3h(unconst_f16(1804.3), unconst_f16(12853.5), unconst_f16(-18901.2))); |
| var vf19: vec2f = unpack2x16float(u32(unconst_u32(49))); |
| return out; |
| _ = override3; |
| _ = override2; |
| } |
| |
| @compute @workgroup_size(1, 1, 2) |
| fn compute2(a0: S0) { |
| vw11.f0 = vec4i(i32(vw12[0].f2[u32(unconst_u32(25))])); |
| var vf20: f16 = vw13[u32(unconst_u32(144))]; |
| var vf21: FragmentOutput2 = workgroupUniformLoad(&vw11); |
| fn1(array<mat2x2h, 1>(mat2x2h())); |
| let ptr48: ptr<private, u32> = &vp2.f0; |
| vw10 = VertexOutput1(vec4f((*&vw12)[0].f3), bitcast<vec2f>((*&vw12)[0].f3), (*&vw12)[0].f3); |
| vw12[u32(vp1.f1[u32(unconst_u32(278))])] = VertexOutput1(vw12[u32(unconst_u32(266))].f2.grrr, vw12[u32(unconst_u32(266))].f2, bitcast<vec4h>(vw12[u32(unconst_u32(266))].f2)); |
| vw13 += (*&vw12)[0].f3; |
| fn2(); |
| vf21 = FragmentOutput2(vec4i((*&vw9).f0[u32(unconst_u32(302))])); |
| let ptr49: ptr<workgroup, vec4h> = &(*&vw10).f3; |
| vw13 -= vec4h(f16((*&vw7).f0)); |
| _ = override4; |
| }`, |
| }); |
| let computePassEncoder39 = commandEncoder49.beginComputePass({}); |
| try { |
| computePassEncoder39.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer8, 'uint16', 188, 270); |
| } catch {} |
| try { |
| commandEncoder50.insertDebugMarker('\u0f1c'); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 992 */ |
| offset: 992, |
| bytesPerRow: 1792, |
| buffer: buffer4, |
| }, { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 8, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline5 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| let buffer29 = device0.createBuffer({ |
| size: 10531, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let computePassEncoder40 = commandEncoder50.beginComputePass({}); |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer23, 228); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder17.resolveQuerySet(querySet1, 54, 28, buffer5, 768); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout14, |
| entries: [{binding: 8, resource: {buffer: buffer5, offset: 5632}}], |
| }); |
| let querySet3 = device0.createQuerySet({type: 'occlusion', count: 447}); |
| let textureView39 = texture1.createView({label: '\u{1f947}\ua1f5\ub825\uaeb4', dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup17, new Uint32Array(2063), 1_795, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup26, new Uint32Array(815), 305, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2584 */ |
| offset: 2584, |
| buffer: buffer3, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout16, |
| entries: [{binding: 8, resource: {buffer: buffer15, offset: 9472, size: 1512}}], |
| }); |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| let texture49 = device0.createTexture({ |
| size: [30, 10, 36], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder9 = commandEncoder47.beginRenderPass({ |
| label: 'k', |
| colorAttachments: [{ |
| view: textureView30, |
| clearValue: { r: 826.5, g: -517.7, b: -183.6, a: 123.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView2, |
| depthClearValue: 0.5749965811186777, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'store', |
| stencilReadOnly: false, |
| }, |
| occlusionQuerySet: querySet2, |
| }); |
| let sampler37 = device0.createSampler({addressModeU: 'repeat', minFilter: 'linear', mipmapFilter: 'linear', compare: 'not-equal'}); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup6, new Uint32Array(155), 37, 0); |
| } catch {} |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let pipeline6 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| let buffer30 = device0.createBuffer({ |
| size: 7898, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder2.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer21, 'uint32', 3_412, 2_551); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(6, buffer24, 15_820); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'smpteSt4281'} }); |
| let autogeneratedBindGroupLayout17 = pipeline1.getBindGroupLayout(0); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 633}); |
| let computePassEncoder41 = commandEncoder4.beginComputePass({}); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup26, new Uint32Array(1448), 236, 0); |
| } catch {} |
| try { |
| buffer17.unmap(); |
| } catch {} |
| try { |
| commandEncoder52.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 132 */ |
| offset: 132, |
| bytesPerRow: 13312, |
| buffer: buffer18, |
| }, { |
| texture: texture30, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 18, resource: textureView0}, |
| {binding: 5, resource: textureView12}, |
| {binding: 20, resource: textureView11}, |
| ], |
| }); |
| try { |
| renderPassEncoder9.beginOcclusionQuery(198); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer29, 'uint16', 550, 740); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(5, buffer17, 2_396, 185); |
| } catch {} |
| let imageData6 = new ImageData(72, 20); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'film', transfer: 'log'} }); |
| let autogeneratedBindGroupLayout18 = pipeline6.getBindGroupLayout(0); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 179}); |
| let computePassEncoder42 = commandEncoder17.beginComputePass({}); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup8, new Uint32Array(1436), 100, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup6, new Uint32Array(4276), 737, 0); |
| } catch {} |
| try { |
| commandEncoder52.clearBuffer(buffer23, 228, 272); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 852, new DataView(new ArrayBuffer(4881)), 189); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| let texture50 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 16}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView40 = texture11.createView({mipLevelCount: 1}); |
| let renderPassEncoder10 = commandEncoder48.beginRenderPass({ |
| label: 'l', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -240.4, g: -380.0, b: -407.5, a: 609.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView20, |
| depthClearValue: 8.154279140696751, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| stencilClearValue: 12532, |
| stencilReadOnly: true, |
| }, |
| maxDrawCount: 219300040, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(3, bindGroup12, new Uint32Array(4057), 481, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| computePassEncoder42.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(321).fill(243), /* required buffer size: 321 */ |
| {offset: 321, rowsPerImage: 68}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte170m', transfer: 'smpte240m'} }); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let textureView41 = texture30.createView({dimension: '3d', mipLevelCount: 1}); |
| let computePassEncoder43 = commandEncoder51.beginComputePass({}); |
| let renderPassEncoder11 = commandEncoder54.beginRenderPass({ |
| label: 'm', |
| colorAttachments: [{view: textureView40, depthSlice: 45, loadOp: 'load', storeOp: 'discard'}], |
| depthStencilAttachment: {view: textureView23, depthReadOnly: true}, |
| occlusionQuerySet: querySet4, |
| }); |
| let sampler38 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.91, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder43.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer28, 'uint32', 640, 1_027); |
| } catch {} |
| try { |
| commandEncoder52.resolveQuerySet(querySet5, 11, 1, buffer21, 1280); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| document.body.prepend(canvas0); |
| let bindGroup32 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 8, resource: {buffer: buffer5, offset: 768}}], |
| }); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup30, new Uint32Array(3658), 601, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0, renderBundle4]); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 30 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2180 */ |
| offset: 2180, |
| buffer: buffer27, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture51 = device0.createTexture({ |
| size: [120, 40, 1], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture52 = device0.createTexture({size: {width: 240}, dimension: '1d', format: 'rgba8sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let renderPassEncoder12 = commandEncoder53.beginRenderPass({ |
| label: 'n', |
| colorAttachments: [{ |
| view: textureView30, |
| clearValue: { r: -635.0, g: 816.4, b: -343.7, a: 694.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView23, |
| depthClearValue: -7.087787716645398, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilClearValue: 41657, |
| stencilReadOnly: false, |
| }, |
| maxDrawCount: 282531233, |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(492).fill(75), /* required buffer size: 492 */ |
| {offset: 476}, {width: 4, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let autogeneratedBindGroupLayout19 = pipeline0.getBindGroupLayout(0); |
| let computePassEncoder44 = commandEncoder55.beginComputePass({}); |
| let renderPassEncoder13 = commandEncoder52.beginRenderPass({ |
| label: 'o', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -682.5, g: -915.2, b: -500.2, a: -45.08, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView20, depthClearValue: 0.7052029111325323, depthLoadOp: 'clear', depthStoreOp: 'store'}, |
| }); |
| let sampler39 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.47, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup30, new Uint32Array(1202), 261, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup30, new Uint32Array(4202), 72, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer14, 176); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer21, 152); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer24, 'uint32', 9_864, 4_593); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 5588, new Int16Array(12372), 2720, 984); |
| } catch {} |
| try { |
| adapter0.label = '\u782d\u4d53\ucb89\u3046'; |
| } catch {} |
| let textureView42 = texture0.createView({dimension: 'cube-array', aspect: 'all', arrayLayerCount: 6}); |
| try { |
| computePassEncoder23.end(); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer11, 252); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer4, 6_496); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1228 */ |
| offset: 1228, |
| buffer: buffer11, |
| }, { |
| texture: texture30, |
| mipLevel: 3, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer31 = device0.createBuffer({size: 9096, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let textureView43 = texture47.createView({mipLevelCount: 1}); |
| let texture53 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView44 = texture46.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder6.draw(31, 163, 1_003_791_427, 104_498_331); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer28, 'uint16', 928, 381); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 124 */ |
| offset: 124, |
| bytesPerRow: 8704, |
| rowsPerImage: 623, |
| buffer: buffer30, |
| }, { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(99).fill(248), /* required buffer size: 99 */ |
| {offset: 99}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let imageData7 = new ImageData(56, 52); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 18, resource: textureView22}, |
| {binding: 20, resource: textureView22}, |
| {binding: 5, resource: textureView12}, |
| ], |
| }); |
| let buffer32 = device0.createBuffer({ |
| size: 24304, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let computePassEncoder45 = commandEncoder56.beginComputePass({}); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup6, new Uint32Array(206), 4, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer4, 1_984); }; |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup16, new Uint32Array(951), 288, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer9, 1_724); |
| } catch {} |
| try { |
| commandEncoder25.resolveQuerySet(querySet1, 69, 7, buffer11, 1024); |
| } catch {} |
| let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470m', transfer: 'gamma28curve'} }); |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| let computePassEncoder46 = commandEncoder25.beginComputePass({}); |
| try { |
| computePassEncoder46.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup23, new Uint32Array(162), 110, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer7, 1_360); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer11, 624); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView45 = texture53.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let sampler40 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 83.76}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup25, new Uint32Array(3714), 1_065, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(2, 191, 858_031_148, 334_811_822); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer9, 388); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| commandEncoder57.copyBufferToBuffer(buffer4, 436, buffer8, 304, 236); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 148, y: 10, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 8, resource: {buffer: buffer15, offset: 9984, size: 836}}], |
| }); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let computePassEncoder47 = commandEncoder58.beginComputePass({}); |
| try { |
| renderPassEncoder6.draw(87, 56, 154_839_956, 943_726_552); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer23, 736); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer30, 1_876); |
| } catch {} |
| let autogeneratedBindGroupLayout20 = pipeline1.getBindGroupLayout(0); |
| let computePassEncoder48 = commandEncoder57.beginComputePass(); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup22, []); |
| } catch {} |
| try { |
| renderPassEncoder2.setViewport(34.685514391725455, 6.600216606569385, 14.04736873602923, 5.290955403892724, 0.764756234350238, 0.9473969486938585); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(86, 405, 561_630_268, 33_930_352); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer4, 376); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer7, 1_188); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer11, 0); |
| } catch {} |
| try { |
| commandEncoder59.resolveQuerySet(querySet2, 297, 142, buffer7, 512); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(354).fill(170), /* required buffer size: 354 */ |
| {offset: 354}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let autogeneratedBindGroupLayout21 = pipeline3.getBindGroupLayout(0); |
| let textureView46 = texture27.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder49 = commandEncoder59.beginComputePass(); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup33); |
| } catch {} |
| try { |
| computePassEncoder47.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer21, 2_832); |
| } catch {} |
| let buffer33 = device0.createBuffer({size: 2987, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle4, renderBundle0, renderBundle0, renderBundle2, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer0, 1_756); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let autogeneratedBindGroupLayout22 = pipeline7.getBindGroupLayout(0); |
| let bindGroup35 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 18, resource: textureView2}, |
| {binding: 5, resource: textureView40}, |
| {binding: 20, resource: textureView0}, |
| ], |
| }); |
| let texture55 = device0.createTexture({size: [30, 10, 22], format: 'rgba8sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let textureView47 = texture32.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder25.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup13, new Uint32Array(469), 53, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(163, 6, 161_992_051, 718_595_568); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer32, 5_916); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer28, 840); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer21, 'uint16', 908, 2_304); |
| } catch {} |
| try { |
| commandEncoder10.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 952 */ |
| offset: 952, |
| bytesPerRow: 25856, |
| buffer: buffer27, |
| }, { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 22, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 53, resource: {buffer: buffer14, offset: 768, size: 484}}], |
| }); |
| let texture56 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder48.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(77); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer28, 1_344); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer17, 0, 378); |
| } catch {} |
| try { |
| commandEncoder10.insertDebugMarker('\u0583'); |
| } catch {} |
| let computePassEncoder50 = commandEncoder10.beginComputePass(); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer11, 1_864); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer24, 'uint16', 4_536, 3_597); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(0, buffer26, 0, 4_891); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| let querySet6 = device0.createQuerySet({type: 'occlusion', count: 553}); |
| let texture57 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView48 = texture48.createView({}); |
| let sampler41 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 38.62, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup15, new Uint32Array(1469), 117, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer32, 4_596); }; |
| } catch {} |
| try { |
| computePassEncoder46.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder6.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: 635.6, g: -166.0, b: 259.9, a: 936.9, }); |
| } catch {} |
| try { |
| computePassEncoder40.insertDebugMarker('\u023c'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 2, y: 3, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(230).fill(36), /* required buffer size: 230 */ |
| {offset: 230}, {width: 7, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let autogeneratedBindGroupLayout23 = pipeline7.getBindGroupLayout(0); |
| let commandEncoder60 = device0.createCommandEncoder(); |
| let textureView49 = texture10.createView({dimension: '2d-array'}); |
| let computePassEncoder51 = commandEncoder60.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer28, 'uint32', 640, 67); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer20); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 220 */ |
| offset: 220, |
| buffer: buffer11, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 12, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData8 = new ImageData(120, 92); |
| let buffer34 = device0.createBuffer({ |
| size: 10839, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView50 = texture34.createView({}); |
| let renderPassEncoder14 = commandEncoder38.beginRenderPass({ |
| label: '[', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -905.8, g: 630.1, b: 901.6, a: -376.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView44, |
| depthClearValue: -8.625265349731299, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| }, |
| occlusionQuerySet: querySet4, |
| maxDrawCount: 87148844, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup8, new Uint32Array(1071), 101, 0); |
| } catch {} |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| computePassEncoder50.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| let arrayBuffer2 = buffer1.getMappedRange(0, 0); |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4804 */ |
| offset: 4804, |
| bytesPerRow: 5888, |
| buffer: buffer31, |
| }, { |
| texture: texture3, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer23, 180, 572); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let bindGroup37 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 53, resource: {buffer: buffer7, offset: 512, size: 1052}}], |
| }); |
| let commandEncoder61 = device0.createCommandEncoder(); |
| let commandBuffer4 = commandEncoder22.finish(); |
| let texture58 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder15 = commandEncoder25.beginRenderPass({ |
| label: 'p', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -696.7, g: -832.6, b: 496.8, a: -351.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView20, depthClearValue: 0.5316383215394045, depthLoadOp: 'clear', depthStoreOp: 'store'}, |
| occlusionQuerySet: querySet2, |
| maxDrawCount: 304370538, |
| }); |
| let sampler42 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 86.99}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder48.setBindGroup(2, bindGroup23, new Uint32Array(2002), 1_652, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer14, 40); }; |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1, renderBundle1, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer28, 'uint32', 1_896, 334); |
| } catch {} |
| try { |
| buffer20.unmap(); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 112 */ |
| offset: 112, |
| buffer: buffer16, |
| }, { |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture59 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| mipLevelCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView51 = texture12.createView({baseArrayLayer: 11, arrayLayerCount: 8}); |
| try { |
| computePassEncoder24.end(); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline3); |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 396, resource: {buffer: buffer32, offset: 5888, size: 344}}], |
| }); |
| let buffer35 = device0.createBuffer({size: 3102, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture60 = device0.createTexture({ |
| size: [120, 40, 147], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder52 = commandEncoder61.beginComputePass({}); |
| try { |
| computePassEncoder42.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| computePassEncoder52.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup34, new Uint32Array(982), 240, 0); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToBuffer({ |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 2, y: 10, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 124 widthInBlocks: 31 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 76 */ |
| offset: 76, |
| bytesPerRow: 32000, |
| buffer: buffer29, |
| }, {width: 31, height: 21, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout24 = pipeline2.getBindGroupLayout(0); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let textureView52 = texture58.createView({}); |
| let texture61 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup22, new Uint32Array(555), 376, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle1, renderBundle1, renderBundle4, renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer29, 'uint16', 1_432, 973); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToBuffer(buffer12, 424, buffer2, 20, 20); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let textureView53 = texture59.createView({dimension: '2d', baseArrayLayer: 2}); |
| let renderPassEncoder16 = commandEncoder62.beginRenderPass({ |
| label: 'q', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -318.5, g: 475.4, b: 912.4, a: 181.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView44, |
| depthClearValue: -6.3924745851588005, |
| depthReadOnly: true, |
| stencilClearValue: 21771, |
| stencilReadOnly: true, |
| }, |
| occlusionQuerySet: querySet2, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup25, new Uint32Array(1253), 37, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle0, renderBundle3, renderBundle2, renderBundle3, renderBundle1, renderBundle1, renderBundle0, renderBundle1, renderBundle2, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(imageBitmap0); |
| let buffer36 = device0.createBuffer({ |
| size: 4499, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture62 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder53 = commandEncoder27.beginComputePass(); |
| let sampler43 = device0.createSampler({addressModeU: 'repeat', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 81.99}); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup38, new Uint32Array(123), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup11, new Uint32Array(5024), 1_475, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer22, 'uint32', 2_380, 6_721); |
| } catch {} |
| let pipeline10 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}}); |
| document.body.prepend(canvas0); |
| let imageData9 = new ImageData(24, 24); |
| try { |
| computePassEncoder31.setBindGroup(1, bindGroup6, new Uint32Array(438), 107, 0); |
| } catch {} |
| try { |
| computePassEncoder53.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(6, buffer33, 0, 156); |
| } catch {} |
| try { |
| sampler18.label = '\u9da4\u0941\u0bde\u{1f75b}\u{1f765}\u0d17\u0e3c\u070e'; |
| } catch {} |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(3, buffer7, 0, 3); |
| } catch {} |
| let img0 = await imageWithData(16, 7, '#10101010', '#20202020'); |
| let textureView54 = texture36.createView({dimension: '2d'}); |
| try { |
| computePassEncoder49.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup5, new Uint32Array(3941), 279, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer37 = device0.createBuffer({size: 3021, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder63 = device0.createCommandEncoder(); |
| let textureView55 = texture59.createView({dimension: '2d'}); |
| let texture63 = device0.createTexture({size: [2, 2, 13], format: 'depth32float', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder54 = commandEncoder63.beginComputePass({}); |
| let sampler44 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 98.21, |
| lodMaxClamp: 99.60, |
| compare: 'greater-equal', |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup17, []); |
| } catch {} |
| try { |
| computePassEncoder54.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer20, 1_064, 664); |
| } catch {} |
| let buffer38 = device0.createBuffer({size: 12308, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let computePassEncoder55 = commandEncoder64.beginComputePass({}); |
| let sampler45 = device0.createSampler({addressModeU: 'repeat', minFilter: 'linear', lodMaxClamp: 54.53, maxAnisotropy: 1}); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer11); |
| } catch {} |
| try { |
| renderPassEncoder11.pushDebugGroup('\u0d73'); |
| } catch {} |
| try { |
| renderPassEncoder11.popDebugGroup(); |
| } catch {} |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder55.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup28, []); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup37, new Uint32Array(342), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(453, 135, 141, 333_264_709, 2_029_850_466); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer7, 1_276); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(4, buffer20, 1_260, 475); |
| } catch {} |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let computePassEncoder56 = commandEncoder65.beginComputePass({}); |
| let sampler46 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.51, |
| maxAnisotropy: 9, |
| }); |
| try { |
| renderPassEncoder8.draw(143, 89, 645_433_777, 1_057_783_849); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(240, 244, 191, 454_492_360, 762_321_167); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 8128, new DataView(new ArrayBuffer(11547)), 1101, 5248); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 871, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout25 = pipeline6.getBindGroupLayout(0); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let computePassEncoder57 = commandEncoder66.beginComputePass(); |
| let sampler47 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 72.73}); |
| try { |
| computePassEncoder56.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(634, 21, 475, 352_990_794, 743_858_668); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer9, 1_132); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline4); |
| } catch {} |
| let autogeneratedBindGroupLayout26 = pipeline2.getBindGroupLayout(0); |
| try { |
| computePassEncoder49.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| computePassEncoder49.setBindGroup(1, bindGroup7, new Uint32Array(3616), 1_185, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setScissorRect(0, 0, 13, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline11 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'always', |
| stencilReadMask: 461226108, |
| depthBiasSlopeScale: 544.0944017778428, |
| depthBiasClamp: -61.440352810426525, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 296, |
| attributes: [ |
| {format: 'snorm16x4', offset: 44, shaderLocation: 5}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 14}, |
| {format: 'float32x4', offset: 20, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'back'}, |
| }); |
| let buffer39 = device0.createBuffer({size: 8155, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder67 = device0.createCommandEncoder(); |
| let computePassEncoder58 = commandEncoder67.beginComputePass({}); |
| try { |
| computePassEncoder55.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder11.beginOcclusionQuery(1); |
| } catch {} |
| try { |
| renderPassEncoder11.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1_104, 447, 35, 407_083_263, 3_775_523); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer26, 1_268); |
| } catch {} |
| let buffer40 = device0.createBuffer({ |
| size: 27421, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture64 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder58.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup30, new Uint32Array(1361), 21, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle2, renderBundle1, renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(201, 133, 56, 585_646_054, 163_622_160); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer4, 320); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer22, 'uint16', 3_746, 6_002); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline3); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 159, resource: {buffer: buffer14, offset: 0, size: 376}}, |
| {binding: 256, resource: {buffer: buffer39, offset: 1024, size: 1079}}, |
| {binding: 290, resource: externalTexture5}, |
| ], |
| }); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let renderPassEncoder17 = commandEncoder68.beginRenderPass({ |
| label: 'r', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: 958.0, g: -618.3, b: -193.0, a: 170.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView20, depthReadOnly: true, stencilClearValue: 17575}, |
| }); |
| let sampler48 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 65.16, compare: 'not-equal'}); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder7.setScissorRect(0, 2, 2, 3); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(86.66754494238742, 32.09210846791985, 19.56139201632414, 2.6903743004394394, 0.5222605343239272, 0.6316506546400393); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(260, 467, 395_384_097, 110_640_387); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer15); |
| } catch {} |
| try { |
| buffer20.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipeline12 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment2', |
| constants: {29_819: 0, 49_292: 0}, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilBack: {compare: 'always'}, |
| stencilReadMask: 138168481, |
| depthBiasClamp: -61.997186408086236, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 200, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'float16x4', offset: 8, shaderLocation: 4}, |
| {format: 'unorm16x2', offset: 64, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 48, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let autogeneratedBindGroupLayout27 = pipeline2.getBindGroupLayout(0); |
| let bindGroup40 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout19, |
| entries: [{binding: 8, resource: {buffer: buffer39, offset: 256, size: 1628}}], |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout10, autogeneratedBindGroupLayout3]}); |
| try { |
| renderPassEncoder8.end(); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer8, 'uint16', 202, 1_111); |
| } catch {} |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let texture65 = device0.createTexture({ |
| size: [120, 40, 19], |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler49 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.66, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup12, new Uint32Array(79), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle1, renderBundle1, renderBundle2, renderBundle2, renderBundle1, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer29, 'uint32', 2_432, 1_648); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer4, 1_628, 1_145); |
| } catch {} |
| document.body.prepend(img0); |
| let commandEncoder70 = device0.createCommandEncoder(); |
| let textureView56 = texture31.createView({aspect: 'depth-only', mipLevelCount: 2, arrayLayerCount: 1}); |
| let computePassEncoder59 = commandEncoder46.beginComputePass({}); |
| let sampler50 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 97.73}); |
| try { |
| computePassEncoder33.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(3, buffer17, 0, 1_863); |
| } catch {} |
| let arrayBuffer3 = buffer1.getMappedRange(40, 0); |
| let autogeneratedBindGroupLayout28 = pipeline6.getBindGroupLayout(0); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer15, offset: 1024, size: 19112}}], |
| }); |
| let commandBuffer5 = commandEncoder70.finish(); |
| let renderPassEncoder18 = commandEncoder69.beginRenderPass({ |
| label: 's', |
| colorAttachments: [{ |
| view: textureView54, |
| clearValue: { r: -590.1, g: 460.0, b: -318.6, a: -82.07, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView23, depthLoadOp: 'load', depthStoreOp: 'discard', stencilClearValue: 26532}, |
| maxDrawCount: 7065944, |
| }); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| let sampler51 = device0.createSampler({minFilter: 'nearest', mipmapFilter: 'linear', lodMaxClamp: 54.44, compare: 'never'}); |
| try { |
| computePassEncoder49.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer29, 'uint16', 3_576, 827); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(img0); |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 53, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer41 = device0.createBuffer({ |
| size: 17965, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let sampler52 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.58, |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder57.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer40, 'uint32', 2_792, 10_448); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer34, 0); |
| } catch {} |
| try { |
| commandEncoder71.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2156 */ |
| offset: 2156, |
| bytesPerRow: 23808, |
| buffer: buffer4, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 8, y: 8, z: 0}, |
| aspect: 'all', |
| }, {width: 12, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture66 = device0.createTexture({ |
| size: [240, 80, 1], |
| mipLevelCount: 3, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler53 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 11.21, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup23, new Uint32Array(5915), 512, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer22, 'uint32', 11_040, 5_779); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(5, buffer20, 0); |
| } catch {} |
| let buffer42 = device0.createBuffer({size: 13841, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let computePassEncoder60 = commandEncoder72.beginComputePass({}); |
| let renderPassEncoder19 = commandEncoder71.beginRenderPass({ |
| label: 't', |
| colorAttachments: [{ |
| view: textureView40, |
| depthSlice: 27, |
| clearValue: { r: 350.7, g: -210.7, b: -343.1, a: 517.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView2, |
| depthClearValue: 5.199783592823097, |
| depthLoadOp: 'load', |
| depthStoreOp: 'store', |
| stencilClearValue: 36761, |
| }, |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup28, []); |
| } catch {} |
| try { |
| computePassEncoder48.setBindGroup(3, bindGroup16, new Uint32Array(722), 88, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer40.unmap(); |
| } catch {} |
| let pipeline13 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilReadMask: 520928205, |
| stencilWriteMask: 675280976, |
| depthBias: -1583981054, |
| depthBiasSlopeScale: 753.258858911692, |
| depthBiasClamp: 100.02075115084338, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex1', |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 64, |
| attributes: [ |
| {format: 'float32x3', offset: 0, shaderLocation: 4}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'front'}, |
| }); |
| let imageData10 = new ImageData(148, 20); |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 189, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer43 = device0.createBuffer({ |
| size: 4635, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder35.setBindGroup(3, bindGroup34, new Uint32Array(3077), 388, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder60.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(6, buffer8, 0); |
| } catch {} |
| await gc(); |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let texture67 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder61 = commandEncoder73.beginComputePass({}); |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder1.setViewport(13.773713024290632, 9.484276040337392, 36.68662383360463, 3.1631652780641213, 0.10697111857616193, 0.6774278519829905); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup13, new Uint32Array(1757), 63, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer36, 'uint16', 2_262, 424); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 1460, new Int16Array(31973), 3760, 396); |
| } catch {} |
| let autogeneratedBindGroupLayout29 = pipeline0.getBindGroupLayout(0); |
| let bindGroup42 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout8, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 4864}}], |
| }); |
| let buffer44 = device0.createBuffer({ |
| size: 728, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler54 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder29.setBindGroup(2, bindGroup13, new Uint32Array(661), 20, 0); |
| } catch {} |
| try { |
| computePassEncoder61.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(2, 9, 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline13); |
| } catch {} |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder44.setBindGroup(3, bindGroup6, new Uint32Array(1097), 317, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder11.setStencilReference(1923); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer44, 'uint32', 212, 286); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline3); |
| } catch {} |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let textureView57 = texture2.createView({aspect: 'depth-only', mipLevelCount: 1}); |
| let computePassEncoder62 = commandEncoder74.beginComputePass({}); |
| let renderBundle5 = renderBundleEncoder5.finish(); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup19, new Uint32Array(964), 22, 0); |
| } catch {} |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(6, 0, 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(6, buffer11); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(182).fill(27), /* required buffer size: 182 */ |
| {offset: 182}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture68 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture69 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 14}, |
| mipLevelCount: 3, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder63 = commandEncoder12.beginComputePass({}); |
| let sampler55 = device0.createSampler({ |
| label: '\u06ac\ufb44\u0032\u064b\u{1fa8a}\uec88', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| lodMaxClamp: 88.68, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout30 = pipeline13.getBindGroupLayout(0); |
| let bindGroup43 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 8, resource: {buffer: buffer30, offset: 1536, size: 424}}], |
| }); |
| let commandEncoder75 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle4, renderBundle5]); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 12, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData11 = new ImageData(36, 28); |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte170m', transfer: 'hlg'} }); |
| let bindGroup44 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout16, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 256}}], |
| }); |
| let textureView58 = texture4.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1}); |
| let sampler56 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder49.setBindGroup(0, bindGroup28, new Uint32Array(2192), 180, 0); |
| } catch {} |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder11.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer34, 6_376, 1_104); |
| } catch {} |
| try { |
| computePassEncoder44.pushDebugGroup('\ud4c7'); |
| } catch {} |
| let buffer45 = device0.createBuffer({size: 8690, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder76 = device0.createCommandEncoder({}); |
| let computePassEncoder64 = commandEncoder76.beginComputePass({}); |
| try { |
| computePassEncoder53.setBindGroup(1, bindGroup39); |
| } catch {} |
| try { |
| computePassEncoder64.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer40, 'uint32', 2_484, 8_637); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer17, offset: 0}}], |
| }); |
| let commandBuffer6 = commandEncoder2.finish(); |
| let texture70 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView59 = texture58.createView({}); |
| try { |
| computePassEncoder64.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder63.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer28, 'uint32', 112, 426); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline13); |
| } catch {} |
| try { |
| computePassEncoder57.pushDebugGroup('\u0d75'); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let offscreenCanvas0 = new OffscreenCanvas(46, 50); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout15, |
| entries: [{binding: 8, resource: {buffer: buffer8, offset: 256, size: 284}}], |
| }); |
| let buffer46 = device0.createBuffer({ |
| size: 3389, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView60 = texture32.createView({aspect: 'depth-only', mipLevelCount: 1}); |
| let sampler57 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMinClamp: 95.14, lodMaxClamp: 99.10}); |
| try { |
| computePassEncoder64.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer38, 432); }; |
| } catch {} |
| try { |
| computePassEncoder13.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup17, new Uint32Array(26), 4, 0); |
| } catch {} |
| try { |
| commandEncoder75.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2780 */ |
| offset: 2780, |
| buffer: buffer28, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 6, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 5, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(4_736).fill(171), /* required buffer size: 4_736 */ |
| {offset: 288, bytesPerRow: 32, rowsPerImage: 17}, {width: 0, height: 4, depthOrArrayLayers: 9}); |
| } catch {} |
| let imageData12 = new ImageData(172, 148); |
| let texture71 = device0.createTexture({ |
| size: [120, 40, 39], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder65 = commandEncoder1.beginComputePass({}); |
| let renderPassEncoder20 = commandEncoder75.beginRenderPass({ |
| label: 'u', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 41, |
| clearValue: { r: 597.2, g: 946.5, b: -277.9, a: 44.40, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView23, depthLoadOp: 'load', depthStoreOp: 'store', stencilClearValue: 65105}, |
| }); |
| let sampler58 = device0.createSampler({addressModeV: 'repeat', minFilter: 'linear', mipmapFilter: 'linear', compare: 'equal'}); |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle3, renderBundle0, renderBundle4, renderBundle1, renderBundle1, renderBundle3, renderBundle2, renderBundle3, renderBundle3, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder17.insertDebugMarker('\u09f5'); |
| } catch {} |
| let pipeline14 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}}); |
| document.body.prepend(img0); |
| let buffer47 = device0.createBuffer({size: 2757, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let texture72 = device0.createTexture({ |
| size: [120], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture73 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba32float', 'rgba32float'], |
| }); |
| let textureView61 = texture33.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 1}); |
| let computePassEncoder66 = commandEncoder54.beginComputePass({}); |
| try { |
| computePassEncoder66.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer46, 'uint16', 154, 162); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer26, 848, 108); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(93).fill(122), /* required buffer size: 93 */ |
| {offset: 93, bytesPerRow: 79, rowsPerImage: 1}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup47 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer5, offset: 6912}}], |
| }); |
| let buffer48 = device0.createBuffer({size: 3339, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandBuffer7 = commandEncoder13.finish({label: '\u092d\uf50a\u9e12\u{1f7f6}\u0d23\u072a\u{1fa9a}\u2263'}); |
| let textureView62 = texture72.createView({format: 'r32uint'}); |
| let sampler59 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 60.07, |
| }); |
| try { |
| computePassEncoder48.setBindGroup(3, bindGroup43, new Uint32Array(463), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder44.popDebugGroup(); |
| } catch {} |
| let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let buffer49 = device0.createBuffer({size: 19896, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture74 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture75 = device0.createTexture({ |
| size: [60, 20, 83], |
| sampleCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu'); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 18, resource: textureView2}, |
| {binding: 20, resource: textureView61}, |
| {binding: 5, resource: textureView12}, |
| ], |
| }); |
| let textureView63 = texture29.createView({}); |
| let texture76 = device0.createTexture({ |
| size: [30, 10, 17], |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup9, []); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer7, 0, 953); |
| } catch {} |
| let arrayBuffer4 = buffer1.getMappedRange(48, 12); |
| let gpuCanvasContext2 = canvas1.getContext('webgpu'); |
| try { |
| externalTexture0.label = '\u006a\u398f\u99be\u10cf\u{1f6a1}'; |
| } catch {} |
| let buffer50 = device0.createBuffer({ |
| size: 747, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView64 = texture28.createView({dimension: '2d'}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder45); computePassEncoder45.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup1, new Uint32Array(34), 20, 0); |
| } catch {} |
| let imageData13 = new ImageData(32, 16); |
| let bindGroup49 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout29, |
| entries: [{binding: 8, resource: {buffer: buffer25, offset: 0, size: 1428}}], |
| }); |
| let buffer51 = device0.createBuffer({size: 8565, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let texture77 = device0.createTexture({ |
| size: {width: 240}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder67 = commandEncoder77.beginComputePass({}); |
| let renderBundle6 = renderBundleEncoder6.finish({}); |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup46, new Uint32Array(285), 103, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(imageData7); |
| let textureView65 = texture77.createView({}); |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup26, []); |
| } catch {} |
| try { |
| renderPassEncoder7.setBlendConstant({ r: 792.4, g: 736.1, b: 381.8, a: 770.8, }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5, commandBuffer7]); |
| } catch {} |
| try { |
| adapter0.label = '\u9e37\u265a\u31fc\u{1fb75}\u85ba\uc1ab\u0f88\u{1fe92}\ufa99'; |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<workgroup> vw14: f16; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw23: atomic<i32>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(8) var<storage, read> buffer52: array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 9>>; |
| |
| var<workgroup> vw15: mat4x2h; |
| |
| struct S2 { |
| @builtin(vertex_index) f0: u32, |
| @location(5) f1: vec4h, |
| @location(10) f2: f32, |
| @location(8) @interpolate(flat) f3: vec2i, |
| @location(0) @interpolate(flat) f4: vec2f, |
| } |
| |
| var<workgroup> vw21: mat4x4h; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw20: array<array<array<array<atomic<i32>, 1>, 1>, 1>, 21>; |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn2() -> array<array<S2, 1>, 1> { |
| var out: array<array<S2, 1>, 1>; |
| out[u32(unconst_u32(9))][u32(unconst_u32(367))].f2 = f32(buffer52[u32(unconst_u32(466))][8][u32(unconst_u32(24))][u32(unconst_u32(31))][u32(unconst_u32(497))][u32(unconst_u32(437))]); |
| out[u32(unconst_u32(78))][u32(unconst_u32(113))] = S2(u32((*&buffer52)[u32(unconst_u32(122))][u32(unconst_u32(92))][u32(buffer52[u32(unconst_u32(143))][u32(unconst_u32(371))][u32(unconst_u32(35))][u32(unconst_u32(263))][0][u32(unconst_u32(124))])][0][u32(unconst_u32(16))][0]), vec4h((*&buffer52)[u32(unconst_u32(122))][u32(unconst_u32(92))][u32(buffer52[u32(unconst_u32(143))][u32(unconst_u32(371))][u32(unconst_u32(35))][u32(unconst_u32(263))][0][u32(unconst_u32(124))])][0][u32(unconst_u32(16))][0]), f32((*&buffer52)[u32(unconst_u32(122))][u32(unconst_u32(92))][u32(buffer52[u32(unconst_u32(143))][u32(unconst_u32(371))][u32(unconst_u32(35))][u32(unconst_u32(263))][0][u32(unconst_u32(124))])][0][u32(unconst_u32(16))][0]), vec2i(i32((*&buffer52)[u32(unconst_u32(122))][u32(unconst_u32(92))][u32(buffer52[u32(unconst_u32(143))][u32(unconst_u32(371))][u32(unconst_u32(35))][u32(unconst_u32(263))][0][u32(unconst_u32(124))])][0][u32(unconst_u32(16))][0])), vec2f(f32((*&buffer52)[u32(unconst_u32(122))][u32(unconst_u32(92))][u32(buffer52[u32(unconst_u32(143))][u32(unconst_u32(371))][u32(unconst_u32(35))][u32(unconst_u32(263))][0][u32(unconst_u32(124))])][0][u32(unconst_u32(16))][0]))); |
| out[u32(unconst_u32(51))][u32(unconst_u32(16))].f3 &= vec2i(i32(buffer52[arrayLength(&buffer52)][u32(unconst_u32(76))][u32(buffer52[u32((*&buffer52)[u32(unconst_u32(94))][8][u32(unconst_u32(214))][u32(unconst_u32(108))][u32(unconst_u32(9))][0])][u32(unconst_u32(178))][2][u32(unconst_u32(78))][u32(unconst_u32(88))][0])][0][0][0])); |
| return out; |
| _ = buffer52; |
| } |
| |
| var<workgroup> vw22: atomic<i32>; |
| |
| struct FragmentOutput3 { |
| @location(0) f0: vec4i, |
| @builtin(frag_depth) f1: f32, |
| } |
| |
| struct S1 { |
| @location(13) f0: u32, |
| @location(14) @interpolate(flat) f1: u32, |
| @location(4) @interpolate(flat) f2: vec4i, |
| @location(6) @interpolate(perspective) f3: vec4h, |
| @location(7) @interpolate(linear, centroid) f4: vec4h, |
| } |
| |
| var<workgroup> vw18: FragmentOutput3; |
| |
| var<workgroup> vw16: vec2h; |
| |
| struct T0 { |
| @size(56) f0: array<mat3x3h>, |
| } |
| |
| fn fn1() -> array<vec4h, 5> { |
| var out: array<vec4h, 5>; |
| let ptr55: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer52)[u32(unconst_u32(165))][u32(buffer52[arrayLength(&buffer52)][u32(unconst_u32(173))][u32(unconst_u32(179))][0][u32(unconst_u32(28))][0])][u32(unconst_u32(91))]; |
| let ptr56: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][8][u32(unconst_u32(59))]; |
| out[u32(unconst_u32(550))] += vec4h(buffer52[u32(unconst_u32(103))][u32(unconst_u32(189))][u32(unconst_u32(20))][0][0][0]); |
| let ptr57: ptr<storage, array<f16, 1>, read> = &buffer52[u32(unconst_u32(161))][8][u32((*&buffer52)[arrayLength(&(*&buffer52))][u32(unconst_u32(15))][u32(unconst_u32(115))][0][u32(unconst_u32(106))][u32(unconst_u32(123))])][0][0]; |
| out[u32((*&buffer52)[u32(unconst_u32(248))][u32(unconst_u32(95))][u32(unconst_u32(96))][0][u32(unconst_u32(229))][0])] = vec4h((*ptr56)[0][0][0]); |
| let ptr58: ptr<storage, array<f16, 1>, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][8][2][u32(unconst_u32(192))][0]; |
| return out; |
| _ = buffer52; |
| } |
| |
| var<workgroup> vw19: mat2x2f; |
| |
| var<workgroup> vw17: mat2x4f; |
| |
| fn fn0(a0: ptr<storage, array<atomic<u32>>, read_write>, a1: ptr<private, vec2<bool>>) -> mat4x2h { |
| var out: mat4x2h; |
| let ptr50: ptr<storage, array<f16, 1>, read> = &(*&buffer52)[u32(unconst_u32(114))][u32(unconst_u32(69))][u32(unconst_u32(29))][0][u32(unconst_u32(81))]; |
| let ptr51: ptr<storage, f16, read> = &buffer52[arrayLength(&buffer52)][u32(unconst_u32(240))][u32(unconst_u32(263))][u32(unconst_u32(304))][0][u32(buffer52[arrayLength(&buffer52)][8][u32(unconst_u32(385))][0][0][0])]; |
| let ptr52: ptr<storage, array<f16, 1>, read> = &buffer52[u32(unconst_u32(156))][8][2][u32(unconst_u32(105))][u32(unconst_u32(89))]; |
| let ptr53: ptr<storage, f16, read> = &buffer52[u32(unconst_u32(113))][u32(unconst_u32(122))][2][0][u32(unconst_u32(264))][u32(unconst_u32(463))]; |
| let ptr54: ptr<storage, f16, read> = &(*ptr50)[u32((*&buffer52)[arrayLength(&(*&buffer52))][8][u32(unconst_u32(222))][u32(unconst_u32(272))][0][0])]; |
| return out; |
| _ = buffer52; |
| } |
| |
| @vertex |
| fn vertex2(@location(12) @interpolate(flat) a0: vec2i, @location(3) a1: vec4u, a2: S1, @location(15) @interpolate(flat) a3: vec4i, @location(2) @interpolate(flat, centroid) a4: vec4u, @location(11) a5: u32, @location(9) @interpolate(flat) a6: f32, a7: S2, @builtin(instance_index) a8: u32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| let ptr59: ptr<storage, array<f16, 1>, read> = &(*&buffer52)[u32(unconst_u32(422))][u32(unconst_u32(162))][2][0][u32(unconst_u32(19))]; |
| let ptr60: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer52)[u32(unconst_u32(348))][u32(unconst_u32(9))][2]; |
| out = unpack4x8unorm(arrayLength(&buffer52)); |
| out = vec4f(f32((*&buffer52)[arrayLength(&(*&buffer52))][u32(unconst_u32(162))][2][u32(unconst_u32(103))][u32(unconst_u32(39))][0])); |
| let ptr61: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer52)[u32(unconst_u32(229))][8][2]; |
| out = vec4f(f32((*ptr60)[0][u32(unconst_u32(39))][u32(unconst_u32(109))])); |
| let ptr62: ptr<storage, f16, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][u32(unconst_u32(200))][u32(unconst_u32(85))][u32(unconst_u32(114))][0][0]; |
| out = vec4f(f32(buffer52[u32(unconst_u32(95))][u32(unconst_u32(287))][2][u32(unconst_u32(61))][0][0])); |
| let ptr63: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 3>, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][u32(unconst_u32(114))]; |
| let ptr64: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 9>, read> = &(*&buffer52)[i32(unconst_i32(13))]; |
| out = vec4f(f32((*ptr61)[0][u32((*ptr63)[2][u32(unconst_u32(437))][0][0])][u32(unconst_u32(621))])); |
| out += vec4f(f32((*&buffer52)[u32(unconst_u32(0))][8][u32(unconst_u32(27))][u32(unconst_u32(697))][0][0])); |
| var vf22 = fn2(); |
| vf22[u32((*ptr64)[u32(unconst_u32(219))][u32(unconst_u32(443))][0][0][0])][u32(unconst_u32(90))] = S2(u32((*&buffer52)[u32(unconst_u32(298))][8][2][0][u32(unconst_u32(10))][0]), vec4h((*&buffer52)[u32(unconst_u32(298))][8][2][0][u32(unconst_u32(10))][0]), f32((*&buffer52)[u32(unconst_u32(298))][8][2][0][u32(unconst_u32(10))][0]), vec2i(i32((*&buffer52)[u32(unconst_u32(298))][8][2][0][u32(unconst_u32(10))][0])), vec2f(f32((*&buffer52)[u32(unconst_u32(298))][8][2][0][u32(unconst_u32(10))][0]))); |
| return out; |
| _ = buffer52; |
| } |
| |
| @fragment |
| fn fragment3() -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| fn1(); |
| fn1(); |
| out.f1 = f32(buffer52[arrayLength(&buffer52)][8][u32(unconst_u32(86))][u32(unconst_u32(117))][u32(unconst_u32(321))][0]); |
| out.f0 = vec4i(i32((*&buffer52)[arrayLength(&(*&buffer52))][8][2][0][0][0])); |
| let ptr65: ptr<storage, array<f16, 1>, read> = &(*&buffer52)[u32(unconst_u32(84))][u32(unconst_u32(14))][2][u32(unconst_u32(307))][0]; |
| out = FragmentOutput3(vec4i(i32(buffer52[arrayLength(&buffer52)][u32(buffer52[u32(unconst_u32(170))][8][u32(unconst_u32(4))][u32(unconst_u32(76))][0][0])][2][u32(unconst_u32(0))][u32(unconst_u32(201))][0])), f32(buffer52[arrayLength(&buffer52)][u32(buffer52[u32(unconst_u32(170))][8][u32(unconst_u32(4))][u32(unconst_u32(76))][0][0])][2][u32(unconst_u32(0))][u32(unconst_u32(201))][0])); |
| let ptr66: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 9>, read> = &(*&buffer52)[i32(unconst_i32(-198))]; |
| let ptr67: ptr<storage, f16, read> = &(*ptr66)[8][2][0][u32(unconst_u32(336))][0]; |
| var vf23 = fn1(); |
| out.f1 = f32(buffer52[u32(unconst_u32(431))][u32(unconst_u32(46))][2][0][0][0]); |
| out.f1 += f32((*&buffer52)[u32(unconst_u32(9))][8][2][0][0][0]); |
| return out; |
| _ = buffer52; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute3() { |
| vw14 = buffer52[arrayLength(&buffer52)][8][2][0][u32(unconst_u32(459))][0]; |
| let ptr68: ptr<storage, f16, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][8][2][pack4xU8Clamp(unpack4xU8(u32(buffer52[arrayLength(&buffer52)][u32(unconst_u32(67))][u32(unconst_u32(341))][u32(unconst_u32(334))][u32(unconst_u32(20))][u32(unconst_u32(351))])))][u32(unconst_u32(588))][u32(unconst_u32(42))]; |
| vw15 -= mat4x2h((*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0], (*&buffer52)[u32(unconst_u32(60))][8][u32(unconst_u32(294))][u32(unconst_u32(76))][0][0]); |
| let ptr69: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 3>, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][8]; |
| vw17 = mat2x4f(bitcast<vec4f>(workgroupUniformLoad(&vw18).f0), vec4f(workgroupUniformLoad(&vw18).f0)); |
| var vf24: i32 = atomicExchange(&(*&vw20)[u32(unconst_u32(177))][u32(unconst_u32(128))][0][u32(unconst_u32(519))], i32(unconst_i32(-247))); |
| let ptr70: ptr<storage, f16, read> = &buffer52[arrayLength(&buffer52)][8][u32(unconst_u32(79))][0][u32(unconst_u32(307))][0]; |
| let ptr71: ptr<workgroup, array<array<atomic<i32>, 1>, 1>> = &vw20[20][0]; |
| atomicExchange(&vw20[20][u32((*&buffer52)[u32(unconst_u32(133))][8][u32(unconst_u32(282))][0][0][0])][0][u32(unconst_u32(922))], i32(unconst_i32(-151))); |
| vf24 = i32((*&buffer52)[u32(unconst_u32(8))][8][u32(unconst_u32(313))][0][0][u32(unconst_u32(124))]); |
| _ = buffer52; |
| }`, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 1, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(196).fill(134), /* required buffer size: 196 */ |
| {offset: 196, bytesPerRow: 219}, {width: 36, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({label: '\u{1ffe5}\u0117\u{1f96d}\u5251\u7d70\u0476\ufaee'}); |
| let commandBuffer8 = commandEncoder78.finish({}); |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder43.setBindGroup(0, bindGroup40, new Uint32Array(590), 20, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup34, new Uint32Array(244), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setScissorRect(9, 2, 7, 12); |
| } catch {} |
| let pipeline15 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| offscreenCanvas0.height = 987; |
| let autogeneratedBindGroupLayout31 = pipeline11.getBindGroupLayout(0); |
| let buffer53 = device0.createBuffer({ |
| size: 9626, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| let textureView66 = texture53.createView({dimension: '2d-array'}); |
| let sampler60 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'greater', |
| maxAnisotropy: 1, |
| }); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 258, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer54 = device0.createBuffer({size: 6207, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder79 = device0.createCommandEncoder({label: '\u{1f762}\u6f15\u2478\uae92\u0080\u0a9f\u03aa\u02a9\u05bd\u0ae4\u4aba'}); |
| let textureView67 = texture77.createView({mipLevelCount: 1}); |
| let renderPassEncoder21 = commandEncoder79.beginRenderPass({ |
| label: 'v', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -478.6, g: 730.5, b: -477.7, a: 511.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView20, |
| depthClearValue: 0.5642293199910583, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'store', |
| stencilClearValue: 3624, |
| }, |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer26, 448); }; |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup6, new Uint32Array(511), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(7, buffer33, 0, 231); |
| } catch {} |
| let texture78 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 60}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder19.executeBundles([renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder19.setViewport(37.59057587284601, 5.555021820711938, 4.672554349941216, 8.476696951432482, 0.5033924923222989, 0.5303501794572869); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout32 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder45.end(); |
| } catch {} |
| try { |
| computePassEncoder55.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToBuffer(buffer28, 48, buffer34, 96, 28); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer6]); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(videoFrame7); |
| let computePassEncoder68 = commandEncoder80.beginComputePass({}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup35); |
| } catch {} |
| let commandBuffer9 = commandEncoder56.finish(); |
| let texture79 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView68 = texture72.createView({baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder41); computePassEncoder41.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder68.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer9, 'uint16', 284, 1_745); |
| } catch {} |
| let texture80 = device0.createTexture({ |
| size: {width: 2}, |
| dimension: '1d', |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler61 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 91.37}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup37, []); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup10, new Uint32Array(1093), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(1, buffer40, 0, 378); |
| } catch {} |
| let textureView69 = texture74.createView({format: 'rg8snorm', mipLevelCount: 1}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| try { |
| renderPassEncoder9.setVertexBuffer(3, buffer38); |
| } catch {} |
| try { |
| buffer27.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder7.insertDebugMarker('\u{1fe0d}'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup50 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 189, resource: textureView42}]}); |
| try { |
| computePassEncoder48.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder28.setBindGroup(0, bindGroup28, new Uint32Array(1295), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup39, new Uint32Array(5106), 1_026, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| computePassEncoder52.pushDebugGroup('\u1fd8'); |
| } catch {} |
| try { |
| renderBundleEncoder7.insertDebugMarker('\u5285'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer50, 164, new Float32Array(13030), 2324, 28); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup51 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 8, resource: {buffer: buffer46, offset: 0, size: 388}}], |
| }); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture81 = device0.createTexture({ |
| size: [240, 80, 32], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView70 = texture40.createView({dimension: 'cube', arrayLayerCount: 6}); |
| let computePassEncoder69 = commandEncoder81.beginComputePass({}); |
| try { |
| computePassEncoder47.setBindGroup(3, bindGroup28); |
| } catch {} |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup51, new Uint32Array(215), 41, 0); |
| } catch {} |
| try { |
| computePassEncoder49.end(); |
| } catch {} |
| try { |
| computePassEncoder69.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer43, 244, 198); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer28, 'uint32', 1_444, 3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(1, buffer40, 0, 2_381); |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'linear'} }); |
| let buffer55 = device0.createBuffer({size: 10927, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let computePassEncoder70 = commandEncoder82.beginComputePass({}); |
| let renderBundle7 = renderBundleEncoder7.finish({}); |
| try { |
| computePassEncoder33.setBindGroup(2, bindGroup45, []); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup1, new Uint32Array(2378), 780, 0); |
| } catch {} |
| try { |
| computePassEncoder41.end(); |
| } catch {} |
| try { |
| computePassEncoder70.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| commandEncoder59.clearBuffer(buffer8, 636, 64); |
| } catch {} |
| let textureView71 = texture13.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder71 = commandEncoder4.beginComputePass({}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| buffer54.unmap(); |
| } catch {} |
| await gc(); |
| let imageData14 = new ImageData(8, 16); |
| let texture82 = device0.createTexture({ |
| size: {width: 2}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView72 = texture68.createView({}); |
| let sampler62 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 60.78, |
| compare: 'less-equal', |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder71.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(6, 4, 11, 0); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2692 */ |
| offset: 2692, |
| bytesPerRow: 4864, |
| buffer: buffer49, |
| }, { |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| canvas0.width = 1702; |
| let bindGroup52 = device0.createBindGroup({ |
| label: '\u0118\u2d41\u{1fec9}\uaad4\uf1be\uaf35\u0ba1\uc09c\u{1ffb8}\u07ee', |
| layout: autogeneratedBindGroupLayout15, |
| entries: [{binding: 8, resource: {buffer: buffer22, offset: 10752, size: 740}}], |
| }); |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| let querySet7 = device0.createQuerySet({type: 'occlusion', count: 23}); |
| let computePassEncoder72 = commandEncoder59.beginComputePass({}); |
| let renderPassEncoder22 = commandEncoder83.beginRenderPass({ |
| label: 'w', |
| colorAttachments: [{view: textureView12, depthSlice: 41, loadOp: 'clear', storeOp: 'store'}], |
| depthStencilAttachment: { |
| view: textureView23, |
| depthLoadOp: 'load', |
| depthStoreOp: 'store', |
| stencilClearValue: 6248, |
| stencilReadOnly: false, |
| }, |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder60.setBindGroup(1, bindGroup52, new Uint32Array(4718), 1_755, 0); |
| } catch {} |
| try { |
| computePassEncoder72.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder57.popDebugGroup(); |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let textureView73 = texture17.createView({}); |
| let computePassEncoder73 = commandEncoder84.beginComputePass({}); |
| try { |
| computePassEncoder65.setBindGroup(2, bindGroup38, new Uint32Array(1351), 68, 0); |
| } catch {} |
| try { |
| computePassEncoder52.popDebugGroup(); |
| } catch {} |
| let pipeline16 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let autogeneratedBindGroupLayout33 = pipeline13.getBindGroupLayout(0); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup37, new Uint32Array(2281), 485, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup34, new Uint32Array(405), 191, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle5, renderBundle7, renderBundle5, renderBundle2, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer29, 'uint16', 2_088, 1_473); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer33, 12); |
| } catch {} |
| let texture83 = device0.createTexture({ |
| size: [30, 10, 1], |
| sampleCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler63 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 82.87, |
| }); |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let querySet8 = device0.createQuerySet({type: 'occlusion', count: 369}); |
| let computePassEncoder74 = commandEncoder85.beginComputePass({}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup41, []); |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline15); |
| } catch {} |
| let pipeline17 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| let buffer56 = device0.createBuffer({size: 15463, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT, mappedAtCreation: false}); |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let renderPassEncoder23 = commandEncoder86.beginRenderPass({ |
| label: 'x', |
| colorAttachments: [{view: textureView12, depthSlice: 4, loadOp: 'clear', storeOp: 'store'}], |
| depthStencilAttachment: {view: textureView58, depthClearValue: -0.27756306406098474, depthReadOnly: true}, |
| }); |
| let sampler64 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 29.95, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder53.end(); |
| } catch {} |
| try { |
| computePassEncoder43.end(); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup8, new Uint32Array(788), 84, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer41.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let textureView74 = texture28.createView({dimension: 'cube'}); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer40, 'uint32', 520, 2_531); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline13); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 8, y: 2, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| document.body.prepend(canvas0); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder71.setBindGroup(3, bindGroup26, new Uint32Array(1743), 30, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer29, 'uint32', 1_752, 60); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer20, 0, 2_363); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| let buffer57 = device0.createBuffer({ |
| size: 367, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let querySet9 = device0.createQuerySet({type: 'occlusion', count: 1}); |
| let textureView75 = texture8.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer28, 'uint16', 1_980, 565); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline4); |
| } catch {} |
| let texture84 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture85 = device0.createTexture({size: [120, 40, 1], format: 'depth32float', usage: GPUTextureUsage.COPY_DST}); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let sampler65 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.12, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(708), 337, 0); |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup12, new Uint32Array(439), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup45); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(5, buffer33, 0, 29); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToBuffer(buffer41, 996, buffer21, 1268, 192); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 5772, new BigUint64Array(4259), 1537, 60); |
| } catch {} |
| let imageData15 = new ImageData(60, 44); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer36, 'uint32', 64, 586); |
| } catch {} |
| try { |
| commandEncoder51.resolveQuerySet(querySet7, 13, 0, buffer41, 4864); |
| } catch {} |
| document.body.prepend(canvas0); |
| let imageBitmap4 = await createImageBitmap(imageData3); |
| let imageData16 = new ImageData(80, 12); |
| let buffer58 = device0.createBuffer({size: 5347, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture86 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder75 = commandEncoder51.beginComputePass({}); |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder75.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer29, 'uint32', 2_828, 799); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToBuffer(buffer4, 2152, buffer17, 308, 452); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(239).fill(188), /* required buffer size: 239 */ |
| {offset: 239, rowsPerImage: 11}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer59 = device0.createBuffer({size: 13709, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let texture87 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler66 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 95.87, compare: 'always'}); |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer21, 'uint16', 662, 450); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer44); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder87.insertDebugMarker('\u{1fab6}'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(49_612).fill(60), /* required buffer size: 49_612 */ |
| {offset: 72, bytesPerRow: 58, rowsPerImage: 122}, {width: 2, height: 1, depthOrArrayLayers: 8}); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let promise5 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{ |
| format: 'rgba8sint', |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'always', |
| stencilBack: {compare: 'always'}, |
| stencilWriteMask: 1657591805, |
| depthBias: -1847628493, |
| }, |
| vertex: {module: shaderModule0, constants: {}, buffers: []}, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw'}, |
| }); |
| try { |
| await promise4; |
| } catch {} |
| let imageData17 = new ImageData(28, 8); |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| let commandBuffer10 = commandEncoder27.finish({}); |
| let computePassEncoder76 = commandEncoder87.beginComputePass({}); |
| let renderBundle8 = renderBundleEncoder8.finish({}); |
| let sampler67 = device0.createSampler({addressModeU: 'repeat'}); |
| try { |
| commandEncoder89.copyTextureToTexture({ |
| texture: texture64, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline18 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| let pipeline19 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x1e13631b}, |
| fragment: { |
| module: shaderModule3, |
| targets: [{ |
| format: 'rgba8sint', |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilReadMask: 1029599521, |
| stencilWriteMask: 613497832, |
| depthBias: -2126780142, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 28, |
| attributes: [ |
| {format: 'snorm16x2', offset: 0, shaderLocation: 14}, |
| {format: 'float32x3', offset: 4, shaderLocation: 4}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back'}, |
| }); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup49); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup33, new Uint32Array(3708), 555, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup15, new Uint32Array(3628), 1_097, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle0, renderBundle2, renderBundle1, renderBundle4]); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 33, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }}, |
| { |
| binding: 203, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder47.setBindGroup(1, bindGroup39, new Uint32Array(3), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup33, new Uint32Array(22), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToBuffer(buffer28, 3560, buffer35, 536, 144); |
| } catch {} |
| try { |
| computePassEncoder57.insertDebugMarker('\ua164'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(2_096).fill(46), /* required buffer size: 2_096 */ |
| {offset: 464, bytesPerRow: 108, rowsPerImage: 7}, {width: 3, height: 2, depthOrArrayLayers: 3}); |
| } catch {} |
| let texture88 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView76 = texture43.createView({baseArrayLayer: 0}); |
| let computePassEncoder77 = commandEncoder91.beginComputePass({}); |
| let sampler68 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.58, |
| compare: 'greater-equal', |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder21.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle4, renderBundle1, renderBundle4, renderBundle1, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline13); |
| } catch {} |
| try { |
| commandEncoder88.copyBufferToTexture({ |
| /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1308 */ |
| offset: 1308, |
| bytesPerRow: 17408, |
| rowsPerImage: 1073, |
| buffer: buffer3, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup53 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 8, resource: {buffer: buffer39, offset: 0, size: 412}}], |
| }); |
| let textureView77 = texture33.createView({mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 4}); |
| let computePassEncoder78 = commandEncoder88.beginComputePass(); |
| try { |
| computePassEncoder76.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| commandEncoder90.insertDebugMarker('\u0795'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 440, new BigUint64Array(11275), 5624, 80); |
| } catch {} |
| let texture89 = device0.createTexture({ |
| size: [60, 20, 1], |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder79 = commandEncoder90.beginComputePass({}); |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup46, new Uint32Array(751), 51, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer38, 4_940); }; |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup23, new Uint32Array(6564), 214, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(6, buffer50, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer57, 12, new Int16Array(22280), 1580, 0); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [{binding: 8, resource: {buffer: buffer15, offset: 21504, size: 2812}}], |
| }); |
| let buffer60 = device0.createBuffer({size: 9877, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let textureView78 = texture63.createView({dimension: 'cube-array', aspect: 'depth-only', arrayLayerCount: 6}); |
| let computePassEncoder80 = commandEncoder92.beginComputePass({}); |
| let sampler69 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.51, |
| compare: 'less-equal', |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder77.setBindGroup(2, bindGroup48, new Uint32Array(2762), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| commandEncoder89.clearBuffer(buffer60, 3156, 904); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout32, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 0}}], |
| }); |
| let renderPassEncoder24 = commandEncoder93.beginRenderPass({ |
| label: 'y', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -239.0, g: 111.3, b: -595.5, a: -560.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView20, |
| depthClearValue: 0.9613332329078684, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilClearValue: 31310, |
| }, |
| occlusionQuerySet: querySet6, |
| maxDrawCount: 26433273, |
| }); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder78.setBindGroup(1, bindGroup36, new Uint32Array(597), 213, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder77.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup6, new Uint32Array(703), 302, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle7, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(1, buffer4); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer57, 112, new Float32Array(8900), 3134, 0); |
| } catch {} |
| let texture90 = device0.createTexture({ |
| size: {width: 120}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView79 = texture26.createView({baseArrayLayer: 16, arrayLayerCount: 1}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup34, new Uint32Array(942), 75, 0); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToBuffer(buffer53, 852, buffer36, 76, 1176); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture80, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(86).fill(221), /* required buffer size: 86 */ |
| {offset: 86}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer61 = device0.createBuffer({ |
| size: 3527, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 191}); |
| let texture91 = device0.createTexture({size: [30, 10, 1], format: 'depth32float', usage: GPUTextureUsage.COPY_SRC}); |
| let sampler70 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'mirror-repeat', lodMaxClamp: 94.88}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer44, 'uint32', 120, 65); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer59, 1_672, 969); |
| } catch {} |
| let textureView80 = texture25.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| try { |
| computePassEncoder79.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup45, new Uint32Array(865), 480, 0); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1232 */ |
| offset: 1232, |
| bytesPerRow: 19200, |
| buffer: buffer20, |
| }, { |
| texture: texture82, |
| mipLevel: 0, |
| 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.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline20 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3}}); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| document.body.append(canvas0); |
| let autogeneratedBindGroupLayout34 = pipeline12.getBindGroupLayout(0); |
| let texture92 = device0.createTexture({ |
| size: [30, 10, 36], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder81 = commandEncoder89.beginComputePass(); |
| try { |
| computePassEncoder79.setBindGroup(2, bindGroup38, new Uint32Array(74), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder48.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 39, y: 28, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(303).fill(72), /* required buffer size: 303 */ |
| {offset: 303, bytesPerRow: 298, rowsPerImage: 47}, {width: 62, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout35 = pipeline14.getBindGroupLayout(0); |
| let buffer62 = device0.createBuffer({ |
| size: 20528, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let querySet11 = device0.createQuerySet({type: 'occlusion', count: 719}); |
| let commandBuffer11 = commandEncoder94.finish(); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(7, buffer39); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer11]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 12}, |
| aspect: 'all', |
| }, new Uint8Array(3_290).fill(245), /* required buffer size: 3_290 */ |
| {offset: 82, bytesPerRow: 40, rowsPerImage: 39}, {width: 1, height: 3, depthOrArrayLayers: 3}); |
| } catch {} |
| let commandEncoder95 = device0.createCommandEncoder(); |
| let computePassEncoder82 = commandEncoder95.beginComputePass({}); |
| let sampler71 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 91.39}); |
| try { |
| renderPassEncoder5.setPipeline(pipeline3); |
| } catch {} |
| let buffer63 = device0.createBuffer({size: 5060, usage: GPUBufferUsage.STORAGE}); |
| try { |
| renderPassEncoder24.setScissorRect(16, 15, 17, 3); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer53, 'uint32', 224, 3_228); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer8, 36); |
| } catch {} |
| let commandEncoder96 = device0.createCommandEncoder({label: '\u4a85\u8b94\u0df1\u{1fa27}\u35b4\u878a\u07e9\u0b07'}); |
| let textureView81 = texture71.createView({dimension: '2d'}); |
| try { |
| computePassEncoder63.setBindGroup(2, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup10, new Uint32Array(2731), 28, 0); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(38, 70); |
| let autogeneratedBindGroupLayout36 = pipeline2.getBindGroupLayout(0); |
| let commandEncoder97 = device0.createCommandEncoder(); |
| let texture93 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture94 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 49}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder83 = commandEncoder96.beginComputePass({}); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup12, new Uint32Array(1159), 287, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer36, 'uint16', 670, 832); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder97.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 204 */ |
| offset: 192, |
| bytesPerRow: 768, |
| buffer: buffer62, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 6, y: 4, z: 19}, |
| aspect: 'all', |
| }, {width: 3, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 696, new Float32Array(663), 89, 44); |
| } catch {} |
| document.body.append(img0); |
| let textureView82 = texture93.createView({}); |
| let computePassEncoder84 = commandEncoder97.beginComputePass({}); |
| try { |
| computePassEncoder39.setBindGroup(2, bindGroup13, new Uint32Array(3508), 464, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup11, new Uint32Array(711), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer50, 0, 17); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 700, new BigUint64Array(1795), 583, 60); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture90, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(2).fill(71), /* required buffer size: 2 */ |
| {offset: 2}, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer32, 6_552); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer46, 'uint16', 626, 169); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte432', transfer: 'bt709'} }); |
| let bindGroup56 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [{binding: 203, resource: {buffer: buffer63, offset: 1024}}, {binding: 33, resource: sampler32}], |
| }); |
| let buffer64 = device0.createBuffer({ |
| size: 9443, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture95 = device0.createTexture({ |
| size: [120, 40, 105], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView83 = texture92.createView({}); |
| let computePassEncoder85 = commandEncoder98.beginComputePass(); |
| try { |
| computePassEncoder69.setBindGroup(1, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| computePassEncoder80.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let buffer65 = device0.createBuffer({size: 23281, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder99 = device0.createCommandEncoder(); |
| let textureView84 = texture0.createView({dimension: '2d'}); |
| try { |
| computePassEncoder57.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline17); |
| } catch {} |
| try { |
| computePassEncoder84.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer30); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToBuffer(buffer47, 64, buffer53, 272, 1704); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'smpte170m'} }); |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| let querySet12 = device0.createQuerySet({type: 'occlusion', count: 405}); |
| let renderPassEncoder25 = commandEncoder20.beginRenderPass({ |
| label: 'z', |
| colorAttachments: [{view: textureView73, depthSlice: 69, loadOp: 'load', storeOp: 'store'}], |
| depthStencilAttachment: {view: textureView79, depthClearValue: 5.698687022757374, depthReadOnly: true, stencilClearValue: 30570}, |
| }); |
| let sampler72 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let textureView85 = texture28.createView({format: 'rg11b10ufloat', baseArrayLayer: 1, arrayLayerCount: 4}); |
| try { |
| computePassEncoder69.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| computePassEncoder79.setBindGroup(0, bindGroup6, new Uint32Array(2233), 57, 0); |
| } catch {} |
| try { |
| computePassEncoder85.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(6, buffer44); |
| } catch {} |
| let bindGroup57 = device0.createBindGroup({layout: autogeneratedBindGroupLayout34, entries: [{binding: 216, resource: textureView24}]}); |
| let textureView86 = texture47.createView({mipLevelCount: 1}); |
| let textureView87 = texture47.createView({mipLevelCount: 1}); |
| try { |
| commandEncoder100.copyBufferToTexture({ |
| /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3652 */ |
| offset: 3652, |
| buffer: buffer55, |
| }, { |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas1); |
| let texture96 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 17}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView88 = texture33.createView({ |
| aspect: 'depth-only', |
| format: 'depth32float', |
| baseMipLevel: 0, |
| mipLevelCount: 1, |
| baseArrayLayer: 7, |
| arrayLayerCount: 2, |
| }); |
| let sampler73 = device0.createSampler({addressModeU: 'repeat', magFilter: 'nearest', lodMaxClamp: 79.95}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup55, []); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer8, 'uint32', 1_896, 29); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer33); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout33, |
| entries: [ |
| {binding: 8, resource: {buffer: buffer43, offset: 768, size: 1884}}, |
| {binding: 216, resource: textureView38}, |
| ], |
| }); |
| let buffer66 = device0.createBuffer({size: 3619, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let texture97 = device0.createTexture({ |
| label: '\u0ee9\u0efd\u{1fe38}\u0420', |
| size: [2, 2, 13], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder86 = commandEncoder100.beginComputePass({}); |
| try { |
| computePassEncoder59.setBindGroup(1, bindGroup7, new Uint32Array(6544), 21, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer12, 2_752); }; |
| } catch {} |
| try { |
| computePassEncoder82.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer8, 'uint16', 306, 59); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer15, 7_264, 17_479); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'bt2020_12bit'} }); |
| let buffer67 = device0.createBuffer({ |
| label: '\u084c\uc8d5\u{1f84e}\u{1fad8}\u01cd\u{1f8fb}\u060a\u6cc3\uf669\u8e32', |
| size: 7499, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let textureView89 = texture74.createView({mipLevelCount: 1}); |
| let texture98 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 67}, |
| mipLevelCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder87 = commandEncoder99.beginComputePass(); |
| let renderPassEncoder26 = commandEncoder101.beginRenderPass({ |
| label: '1', |
| colorAttachments: [{view: textureView30, loadOp: 'clear', storeOp: 'store'}], |
| depthStencilAttachment: {view: textureView2, depthClearValue: 4.786577580045957, depthReadOnly: true, stencilClearValue: 10555}, |
| maxDrawCount: 203381158, |
| }); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout37 = pipeline0.getBindGroupLayout(0); |
| try { |
| computePassEncoder78.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle2, renderBundle3, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup26, new Uint32Array(3630), 332, 0); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| let buffer68 = device0.createBuffer({ |
| size: 2078, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let renderBundle9 = renderBundleEncoder9.finish({}); |
| let sampler74 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.41, |
| maxAnisotropy: 16, |
| }); |
| try { |
| renderPassEncoder17.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(5, buffer9, 0, 805); |
| } catch {} |
| let textureView90 = texture93.createView({}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| let renderBundle10 = renderBundleEncoder10.finish({}); |
| try { |
| computePassEncoder80.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup51, new Uint32Array(2272), 10, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup54, new Uint32Array(786), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer22, 'uint32', 412, 232); |
| } catch {} |
| let autogeneratedBindGroupLayout38 = pipeline16.getBindGroupLayout(0); |
| let buffer69 = device0.createBuffer({ |
| size: 784, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView91 = texture34.createView({}); |
| let sampler75 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'clamp-to-edge', minFilter: 'nearest'}); |
| try { |
| computePassEncoder81.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup51, []); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer29, 'uint16', 1_572, 888); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'}); |
| } catch {} |
| let gpuCanvasContext3 = offscreenCanvas1.getContext('webgpu'); |
| let buffer70 = device0.createBuffer({ |
| size: 11800, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler76 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder86.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder59.setBindGroup(3, bindGroup41, new Uint32Array(709), 118, 0); |
| } catch {} |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| commandEncoder11.copyTextureToBuffer({ |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'depth-only', |
| }, { |
| /* bytesInLastRow: 120 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 272 */ |
| offset: 272, |
| bytesPerRow: 35328, |
| buffer: buffer4, |
| }, {width: 30, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder11.resolveQuerySet(querySet3, 75, 30, buffer44, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(185).fill(148), /* required buffer size: 185 */ |
| {offset: 185}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup59 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout32, |
| entries: [{binding: 8, resource: {buffer: buffer14, offset: 0, size: 212}}], |
| }); |
| let buffer71 = device0.createBuffer({size: 15557, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let renderPassEncoder27 = commandEncoder11.beginRenderPass({label: '2', colorAttachments: [{view: textureView15, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder39.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup45, new Uint32Array(228), 65, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline19); |
| } catch {} |
| let textureView92 = texture28.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup17); |
| } catch {} |
| let textureView93 = texture28.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 2}); |
| let sampler77 = device0.createSampler({lodMaxClamp: 81.59, compare: 'not-equal'}); |
| try { |
| computePassEncoder86.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder20.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout39 = pipeline11.getBindGroupLayout(0); |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| let texture99 = device0.createTexture({ |
| size: [60, 20, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder88 = commandEncoder102.beginComputePass(); |
| try { |
| computePassEncoder88.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup31, new Uint32Array(804), 340, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle5, renderBundle6, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder23.setStencilReference(1879); |
| } catch {} |
| await gc(); |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 396, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture100 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler78 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| lodMaxClamp: 44.94, |
| compare: 'equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup35, []); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder21.setBlendConstant({ r: -444.4, g: -949.8, b: -454.0, a: 906.3, }); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(3, buffer64); |
| } catch {} |
| try { |
| renderPassEncoder22.insertDebugMarker('\u0fc0'); |
| } catch {} |
| let img1 = await imageWithData(2, 87, '#10101010', '#20202020'); |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'jedecP22Phosphors', transfer: 'logSqrt'} }); |
| let texture101 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 56}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float'}); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup39, new Uint32Array(2700), 432, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(5, buffer29, 0, 2_255); |
| } catch {} |
| try { |
| buffer54.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout40 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let querySet13 = device0.createQuerySet({type: 'occlusion', count: 5}); |
| let textureView94 = texture74.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder89 = commandEncoder103.beginComputePass({}); |
| let renderBundle11 = renderBundleEncoder11.finish(); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup23, []); |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(3, buffer24, 0, 14_588); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\uc426'); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 290, resource: externalTexture10}, |
| {binding: 159, resource: {buffer: buffer5, offset: 1024}}, |
| {binding: 256, resource: {buffer: buffer15, offset: 13568, size: 8094}}, |
| ], |
| }); |
| let textureView95 = texture47.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder89.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer9, 'uint16', 2_584, 3_002); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 49, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(9_892).fill(220), /* required buffer size: 9_892 */ |
| {offset: 12, bytesPerRow: 52, rowsPerImage: 26}, {width: 0, height: 9, depthOrArrayLayers: 8}); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise6; |
| } catch {} |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 54, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let computePassEncoder90 = commandEncoder104.beginComputePass({}); |
| let sampler79 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 21.43, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder50.setBindGroup(2, bindGroup11, new Uint32Array(88), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup51, new Uint32Array(1807), 324, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout41 = pipeline17.getBindGroupLayout(0); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| let texture102 = device0.createTexture({ |
| size: [120], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder91 = commandEncoder105.beginComputePass(); |
| try { |
| computePassEncoder91.setBindGroup(3, bindGroup6, new Uint32Array(1905), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setViewport(38.46101498225467, 3.0909525508578373, 3.8687232392674464, 5.602490404892497, 0.15091331820149645, 0.9327056222239721); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout42 = pipeline16.getBindGroupLayout(0); |
| let buffer72 = device0.createBuffer({size: 4772, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let commandEncoder106 = device0.createCommandEncoder(); |
| let textureView96 = texture56.createView({}); |
| let computePassEncoder92 = commandEncoder106.beginComputePass({}); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline16); |
| } catch {} |
| try { |
| computePassEncoder91.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer44, 'uint16', 232, 5); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(2, buffer62, 0, 3_308); |
| } catch {} |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let computePassEncoder93 = commandEncoder107.beginComputePass({}); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup25, new Uint32Array(1559), 91, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle11, renderBundle7, renderBundle8, renderBundle11, renderBundle5, renderBundle0, renderBundle6, renderBundle8, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer44); |
| } catch {} |
| try { |
| buffer60.unmap(); |
| } catch {} |
| let recycledExplicitBindGroupLayout0 = pipeline5.getBindGroupLayout(0); |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| let commandBuffer12 = commandEncoder108.finish(); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder92.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let commandEncoder109 = device0.createCommandEncoder(); |
| let computePassEncoder94 = commandEncoder109.beginComputePass({}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup23, new Uint32Array(2350), 54, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(5, buffer69); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 836, new Int16Array(13760), 3452, 152); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 15, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(45).fill(240), /* required buffer size: 45 */ |
| {offset: 45, bytesPerRow: 145}, {width: 5, height: 16, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture103 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 11}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder60.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder90.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline4); |
| } catch {} |
| let bindGroup61 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 8, resource: {buffer: buffer53, offset: 1536, size: 56}}], |
| }); |
| let textureView97 = texture102.createView({}); |
| let sampler80 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 65.52, |
| lodMaxClamp: 72.02, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder55.setBindGroup(0, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup13, new Uint32Array(1492), 697, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder60); computePassEncoder60.dispatchWorkgroupsIndirect(buffer4, 660); }; |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle1, renderBundle9, renderBundle1, renderBundle6, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u08c5'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(457).fill(60), /* required buffer size: 457 */ |
| {offset: 337, bytesPerRow: 1, rowsPerImage: 23}, {width: 0, height: 6, depthOrArrayLayers: 6}); |
| } catch {} |
| let imageData18 = new ImageData(40, 44); |
| let textureView98 = texture75.createView({aspect: 'depth-only', baseArrayLayer: 6, arrayLayerCount: 7}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup53, []); |
| } catch {} |
| try { |
| computePassEncoder68.setBindGroup(1, bindGroup8, new Uint32Array(1676), 187, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroupsIndirect(buffer15, 5_436); }; |
| } catch {} |
| try { |
| computePassEncoder93.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup5, new Uint32Array(1393), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder3.setViewport(3.5901499914368484, 10.56768838557312, 26.895848434603153, 3.019387330132418, 0.911973758253343, 0.9751321683094214); |
| } catch {} |
| let pipeline21 = device0.createComputePipeline({ |
| layout: pipelineLayout1, |
| compute: {module: shaderModule2, entryPoint: 'compute2', constants: {override4: 0}}, |
| }); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let texture104 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder95 = commandEncoder110.beginComputePass({}); |
| let sampler81 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 99.67}); |
| try { |
| computePassEncoder89.setBindGroup(3, bindGroup1, new Uint32Array(3862), 276, 0); |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup13, new Uint32Array(469), 159, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer33.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let texture105 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 13}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let texture106 = gpuCanvasContext2.getCurrentTexture(); |
| let sampler82 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.13, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer40, 'uint32', 1_876, 619); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer20, 548, 313); |
| } catch {} |
| let computePassEncoder96 = commandEncoder29.beginComputePass({}); |
| let sampler83 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 99.66, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer64, 'uint16', 86, 3_405); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer46, 0); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 35, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup62 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 203, resource: {buffer: buffer15, offset: 5632, size: 17884}}, |
| {binding: 33, resource: sampler69}, |
| ], |
| }); |
| let textureView99 = texture61.createView({dimension: 'cube', aspect: 'all'}); |
| let sampler84 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 86.67, |
| lodMaxClamp: 98.81, |
| }); |
| try { |
| computePassEncoder95.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup62, new Uint32Array(382), 96, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setStencilReference(299); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer46, 'uint16', 290, 79); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12]); |
| } catch {} |
| try { |
| computePassEncoder96.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(52.75641112165022, 10.494968568541374, 23.950440295757144, 5.693733226632708, 0.0678243882431141, 0.2524412054243823); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline11); |
| } catch {} |
| let imageData19 = new ImageData(12, 100); |
| let bindGroup63 = device0.createBindGroup({layout: autogeneratedBindGroupLayout34, entries: [{binding: 216, resource: textureView24}]}); |
| let buffer73 = device0.createBuffer({size: 7137, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder87.setBindGroup(2, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder88.setBindGroup(1, bindGroup37, new Uint32Array(745), 379, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup23, new Uint32Array(725), 77, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(4, buffer8, 0, 774); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture66, |
| mipLevel: 1, |
| origin: {x: 13, y: 12, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(52).fill(248), /* required buffer size: 52 */ |
| {offset: 52, bytesPerRow: 185}, {width: 36, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout25]}); |
| let commandEncoder111 = device0.createCommandEncoder(); |
| let texture107 = device0.createTexture({ |
| size: [120, 40, 147], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler85 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat'}); |
| try { |
| computePassEncoder77.setBindGroup(2, bindGroup63, new Uint32Array(1064), 510, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder60); computePassEncoder60.dispatchWorkgroupsIndirect(buffer19, 1_496); }; |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer33, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 8, y: 9 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 39, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 31, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| let computePassEncoder97 = commandEncoder112.beginComputePass({}); |
| try { |
| computePassEncoder50.setBindGroup(1, bindGroup31, new Uint32Array(3901), 105, 0); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer62, 'uint16', 3_424, 1_149); |
| } catch {} |
| let autogeneratedBindGroupLayout43 = pipeline16.getBindGroupLayout(0); |
| let computePassEncoder98 = commandEncoder111.beginComputePass({}); |
| let sampler86 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 97.43}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup34, new Uint32Array(357), 17, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder55); computePassEncoder55.dispatchWorkgroupsIndirect(buffer44, 200); }; |
| } catch {} |
| try { |
| computePassEncoder98.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder16.setViewport(98.0573104874695, 9.300178119174053, 20.821443153091373, 3.6158600139569015, 0.6521293556637312, 0.6995921792039166); |
| } catch {} |
| let bindGroup64 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 8, resource: {buffer: buffer12, offset: 0, size: 4952}}], |
| }); |
| try { |
| computePassEncoder97.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup15); |
| } catch {} |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderPassEncoder2.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, buffer4, 6_868); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup13, new Uint32Array(218), 69, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer62, 'uint16', 818, 2_322); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer43, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout44 = pipeline12.getBindGroupLayout(0); |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let texture108 = device0.createTexture({ |
| size: [240, 80, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder99 = commandEncoder113.beginComputePass({}); |
| let renderBundle12 = renderBundleEncoder12.finish({label: '\u{1f946}\u4094\u{1f637}\u{1fc2f}\u9b55\u{1fbe8}\u0aed'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder55); computePassEncoder55.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup51, new Uint32Array(935), 93, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setViewport(28.55691233134902, 3.1780958155599315, 25.219956479923265, 5.6689207034485944, 0.5701937638872513, 0.7268503891161959); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup65 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 8, resource: {buffer: buffer70, offset: 1280}}], |
| }); |
| let commandEncoder114 = device0.createCommandEncoder(); |
| let commandBuffer13 = commandEncoder114.finish(); |
| let texture109 = device0.createTexture({size: [120, 40, 147], dimension: '3d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup40, new Uint32Array(2466), 65, 0); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| let bindGroup66 = device0.createBindGroup({ |
| label: '\u4e27\u{1febe}\u{1ff99}', |
| layout: veryExplicitBindGroupLayout6, |
| entries: [{binding: 8, resource: {buffer: buffer22, offset: 15104, size: 1280}}], |
| }); |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let texture110 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 147}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let renderPassEncoder28 = commandEncoder115.beginRenderPass({ |
| label: '3', |
| colorAttachments: [{view: textureView71, loadOp: 'clear', storeOp: 'discard'}], |
| maxDrawCount: 75620451, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup51); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer53, 'uint32', 1_028, 1_687); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline4); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let bindGroup67 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout14, |
| entries: [{binding: 8, resource: {buffer: buffer41, offset: 8960, size: 720}}], |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer36, 'uint16', 64, 193); |
| } catch {} |
| try { |
| commandEncoder116.copyBufferToBuffer(buffer12, 2364, buffer34, 2460, 6620); |
| } catch {} |
| try { |
| commandEncoder116.resolveQuerySet(querySet9, 0, 0, buffer7, 512); |
| } catch {} |
| try { |
| computePassEncoder50.insertDebugMarker('\udf4d'); |
| } catch {} |
| let buffer74 = device0.createBuffer({ |
| size: 9496, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let renderPassEncoder29 = commandEncoder116.beginRenderPass({ |
| label: '4', |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: 685.3, g: -748.0, b: 463.4, a: 399.5, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView44, depthReadOnly: true, stencilClearValue: 23030, stencilReadOnly: false}, |
| }); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder55.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer69, 'uint32', 104, 66); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1028 */ |
| offset: 1028, |
| bytesPerRow: 1792, |
| buffer: buffer56, |
| }, { |
| texture: texture102, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(175).fill(70), /* required buffer size: 175 */ |
| {offset: 175, rowsPerImage: 22}, {width: 30, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline22 = await promise2; |
| document.body.prepend(img1); |
| let buffer75 = device0.createBuffer({size: 6095, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let textureView100 = texture98.createView({dimension: '2d', format: 'rgba8sint', baseArrayLayer: 12}); |
| let computePassEncoder100 = commandEncoder64.beginComputePass({}); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup64); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder100.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup54, new Uint32Array(381), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer29, 'uint32', 832, 3_249); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(7, buffer26, 0, 814); |
| } catch {} |
| try { |
| commandEncoder117.copyBufferToBuffer(buffer56, 5816, buffer29, 5532, 3832); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 288, new Float32Array(12440), 194, 36); |
| } catch {} |
| let bindGroup68 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 8, resource: {buffer: buffer49, offset: 768}}], |
| }); |
| let textureView101 = texture107.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder101 = commandEncoder117.beginComputePass({}); |
| try { |
| renderPassEncoder17.setBlendConstant({ r: -737.0, g: 228.5, b: 268.4, a: 646.6, }); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline4); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder91.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline22); |
| } catch {} |
| let pipeline23 = await promise5; |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let renderPassEncoder30 = commandEncoder118.beginRenderPass({ |
| label: '5', |
| colorAttachments: [{ |
| view: textureView73, |
| depthSlice: 79, |
| clearValue: { r: -50.22, g: 334.1, b: -662.7, a: 24.16, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView20, depthReadOnly: true, stencilClearValue: 37870, stencilReadOnly: false}, |
| maxDrawCount: 267366526, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(12); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer44, 'uint16', 102, 78); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline12); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let autogeneratedBindGroupLayout45 = pipeline3.getBindGroupLayout(0); |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout23]}); |
| let sampler87 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 86.53}); |
| try { |
| computePassEncoder101.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup46, new Uint32Array(1121), 182, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer59, 0, 2_331); |
| } catch {} |
| let autogeneratedBindGroupLayout46 = pipeline14.getBindGroupLayout(0); |
| let buffer76 = device0.createBuffer({ |
| size: 10648, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let sampler88 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.45, |
| compare: 'always', |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup46, new Uint32Array(2158), 255, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle11]); |
| } catch {} |
| let buffer77 = device0.createBuffer({ |
| size: 32964, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture111 = device0.createTexture({ |
| size: [60, 20, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer69, 'uint32', 88, 418); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer24, 0, 16_692); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(6_468).fill(76), /* required buffer size: 6_468 */ |
| {offset: 73, bytesPerRow: 77, rowsPerImage: 41}, {width: 1, height: 2, depthOrArrayLayers: 3}); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let texture112 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgb10a2uint'], |
| }); |
| try { |
| computePassEncoder60.setBindGroup(3, bindGroup48, new Uint32Array(184), 53, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBlendConstant({ r: 447.8, g: -996.6, b: 18.24, a: -642.3, }); |
| } catch {} |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer24, 'uint32', 1_136, 2_872); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame11, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 16, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup69 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout20, |
| entries: [{binding: 8, resource: {buffer: buffer23, offset: 1280, size: 204}}], |
| }); |
| let buffer78 = device0.createBuffer({ |
| size: 2716, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder54.setBindGroup(0, bindGroup7, new Uint32Array(3826), 2_251, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer56, 3_392); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup67, new Uint32Array(833), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setViewport(36.689217974202656, 13.876907807118936, 4.437919558770667, 2.1137180289943385, 0.5968029325283659, 0.7639930697340673); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer36, 'uint16', 68, 1_478); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer62, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline24 = device0.createRenderPipeline({ |
| label: 'aaa', |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'always', |
| stencilReadMask: 21175866, |
| stencilWriteMask: 133367085, |
| depthBiasSlopeScale: 622.6705603081632, |
| }, |
| vertex: {module: shaderModule0, constants: {}, buffers: []}, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let autogeneratedBindGroupLayout47 = pipeline22.getBindGroupLayout(0); |
| let querySet14 = device0.createQuerySet({type: 'occlusion', count: 247}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder77.setBindGroup(3, bindGroup39, new Uint32Array(2684), 51, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder27.setViewport(2.755819882650181, 50.697284780969305, 67.0886292121161, 4.005073330723198, 0.021308173007800524, 0.3987961708658724); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| renderPassEncoder14.insertDebugMarker('\uc7ee'); |
| } catch {} |
| let autogeneratedBindGroupLayout48 = pipeline23.getBindGroupLayout(0); |
| try { |
| computePassEncoder95.setBindGroup(1, bindGroup61, new Uint32Array(189), 29, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder60); computePassEncoder60.dispatchWorkgroupsIndirect(buffer14, 484); }; |
| } catch {} |
| try { |
| computePassEncoder78.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(1, buffer73, 1_980, 1_029); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer79 = device0.createBuffer({size: 373, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder119 = device0.createCommandEncoder(); |
| let computePassEncoder102 = commandEncoder119.beginComputePass(); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup55, new Uint32Array(2556), 1_059, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder102.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle1, renderBundle12]); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| computePassEncoder86.insertDebugMarker('\u05bc'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 45, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture113 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView102 = texture59.createView({dimension: 'cube', baseArrayLayer: 2}); |
| let sampler89 = device0.createSampler({addressModeV: 'mirror-repeat', magFilter: 'linear', minFilter: 'linear', lodMaxClamp: 98.07}); |
| try { |
| computePassEncoder99.setPipeline(pipeline7); |
| } catch {} |
| try { |
| await buffer65.mapAsync(GPUMapMode.WRITE, 0, 1320); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout21, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 256}}], |
| }); |
| let buffer80 = device0.createBuffer({size: 9329, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let textureView103 = texture59.createView({dimension: 'cube', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let textureView104 = texture108.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| let sampler90 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat'}); |
| try { |
| computePassEncoder32.setPipeline(pipeline8); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, alphaMode: 'opaque'}); |
| } catch {} |
| let buffer81 = device0.createBuffer({size: 24278, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 304}); |
| let texture114 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup51, new Uint32Array(504), 5, 0); |
| } catch {} |
| try { |
| commandEncoder5.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 916 */ |
| offset: 916, |
| rowsPerImage: 939, |
| buffer: buffer51, |
| }, { |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let texture115 = device0.createTexture({size: [2, 2, 13], format: 'rgba16uint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| let computePassEncoder103 = commandEncoder5.beginComputePass({}); |
| let sampler91 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'greater-equal', |
| }); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder103.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup25, new Uint32Array(2699), 358, 0); |
| } catch {} |
| try { |
| texture94.destroy(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 11, y: 16 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 298, y: 19, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas1); |
| let buffer82 = device0.createBuffer({ |
| size: 2694, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture116 = device0.createTexture({size: [30, 10, 1], format: 'depth32float', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder3.executeBundles([renderBundle6, renderBundle4, renderBundle2, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline19); |
| } catch {} |
| try { |
| buffer80.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData17, |
| origin: { x: 4, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 175, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout1 = pipeline21.getBindGroupLayout(0); |
| let buffer83 = device0.createBuffer({size: 8687, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let texture117 = device0.createTexture({ |
| size: [120, 40, 1], |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView105 = texture58.createView({}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup51); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder120.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 892 */ |
| offset: 892, |
| bytesPerRow: 8960, |
| buffer: buffer3, |
| }, { |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame13 = new VideoFrame(imageBitmap1, {timestamp: 0}); |
| let buffer84 = device0.createBuffer({ |
| size: 6122, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder90.setBindGroup(2, bindGroup61, new Uint32Array(2024), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup35, new Uint32Array(1454), 128, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline23); |
| } catch {} |
| let pipeline25 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| try { |
| globalThis.someLabel = autogeneratedBindGroupLayout34.label; |
| } catch {} |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| let textureView106 = texture61.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 2}); |
| let computePassEncoder104 = commandEncoder120.beginComputePass({}); |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup51, []); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup41, new Uint32Array(1497), 668, 0); |
| } catch {} |
| let pipeline26 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rgba8sint'}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: {}, |
| stencilReadMask: 752315593, |
| stencilWriteMask: 241962736, |
| depthBias: 0, |
| depthBiasSlopeScale: 427.1794136799574, |
| depthBiasClamp: 462.8842022566364, |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex2', |
| buffers: [ |
| { |
| arrayStride: 80, |
| attributes: [ |
| {format: 'float32', offset: 20, shaderLocation: 0}, |
| {format: 'float32', offset: 0, shaderLocation: 10}, |
| {format: 'uint32', offset: 8, shaderLocation: 13}, |
| {format: 'float16x2', offset: 8, shaderLocation: 7}, |
| {format: 'sint32x4', offset: 4, shaderLocation: 12}, |
| {format: 'uint8x2', offset: 44, shaderLocation: 14}, |
| {format: 'sint32x3', offset: 8, shaderLocation: 8}, |
| {format: 'uint32x4', offset: 40, shaderLocation: 3}, |
| {format: 'sint8x2', offset: 22, shaderLocation: 15}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 2}, |
| {format: 'float32x4', offset: 0, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 6}, |
| {format: 'float32x2', offset: 4, shaderLocation: 5}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 4}, |
| ], |
| }, |
| {arrayStride: 752, attributes: [{format: 'uint32x4', offset: 20, shaderLocation: 11}]}, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front'}, |
| }); |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'linear'} }); |
| let bindGroup71 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout48, |
| entries: [{binding: 8, resource: {buffer: buffer61, offset: 256, size: 184}}], |
| }); |
| let texture118 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder31 = commandEncoder121.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: 664.4, g: 376.7, b: 27.61, a: -958.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| sampleCount: 1, |
| stencilReadOnly: false, |
| }); |
| try { |
| computePassEncoder84.setBindGroup(3, bindGroup69, new Uint32Array(986), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer70, 0, 1_283); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(1, bindGroup67); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 316, new Float32Array(1036), 52, 12); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| try { |
| globalThis.someLabel = computePassEncoder11.label; |
| } catch {} |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let computePassEncoder105 = commandEncoder122.beginComputePass({}); |
| let renderBundle13 = renderBundleEncoder13.finish({}); |
| try { |
| computePassEncoder71.setBindGroup(0, bindGroup49, new Uint32Array(2586), 40, 0); |
| } catch {} |
| try { |
| computePassEncoder60.end(); |
| } catch {} |
| try { |
| computePassEncoder104.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(2, bindGroup63); |
| } catch {} |
| try { |
| commandEncoder72.copyBufferToBuffer(buffer47, 468, buffer75, 536, 364); |
| } catch {} |
| let bindGroup72 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [{binding: 33, resource: sampler5}, {binding: 203, resource: {buffer: buffer62, offset: 3840}}], |
| }); |
| let arrayBuffer5 = buffer65.getMappedRange(0, 112); |
| try { |
| commandEncoder72.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 684 */ |
| offset: 684, |
| buffer: buffer47, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 19, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 24, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup73 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [{binding: 8, resource: {buffer: buffer49, offset: 1024}}], |
| }); |
| let buffer85 = device0.createBuffer({ |
| size: 2744, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture119 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 26}, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder32 = commandEncoder72.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 51, |
| clearValue: { r: -724.1, g: -466.1, b: 572.8, a: -353.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView58, |
| depthClearValue: 8.298106651158037, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| }, |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 163992768, |
| }); |
| try { |
| computePassEncoder105.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(1, bindGroup36, new Uint32Array(1124), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(2, buffer46, 0, 93); |
| } catch {} |
| let textureView107 = texture71.createView({dimension: '2d-array', arrayLayerCount: 5}); |
| let sampler92 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 91.76, |
| }); |
| try { |
| computePassEncoder35.setBindGroup(1, bindGroup5, new Uint32Array(1415), 220, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer9, 'uint16', 760, 777); |
| } catch {} |
| try { |
| commandEncoder28.copyTextureToBuffer({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1768 */ |
| offset: 1768, |
| buffer: buffer74, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder28.resolveQuerySet(querySet11, 5, 150, buffer26, 1024); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout49 = pipeline14.getBindGroupLayout(0); |
| let texture120 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture121 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView108 = texture73.createView({label: '\u{1f7a0}\uff4e\u4cb3\u04ef', dimension: '2d-array', baseArrayLayer: 0}); |
| let computePassEncoder106 = commandEncoder28.beginComputePass(); |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer83, 'uint16', 2_126, 108); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline26); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 310, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 13, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 33, height: 21, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext4 = canvas2.getContext('webgpu'); |
| let bindGroup74 = device0.createBindGroup({layout: autogeneratedBindGroupLayout44, entries: [{binding: 216, resource: textureView92}]}); |
| let commandEncoder123 = device0.createCommandEncoder({}); |
| let texture122 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture123 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView109 = texture123.createView({dimension: 'cube-array', aspect: 'depth-only', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let renderPassEncoder33 = commandEncoder123.beginRenderPass({ |
| label: '\uf963\u0043\u{1fe1c}\u{1fe3e}\ua77c\u{1fe28}\u{1fce4}', |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: -148.1, g: -603.8, b: 629.7, a: 852.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder106.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(3, bindGroup64, new Uint32Array(6230), 4_398, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle9, renderBundle11, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer29, 'uint16', 1_582, 761); |
| } catch {} |
| let buffer86 = device0.createBuffer({ |
| size: 30476, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView110 = texture122.createView({format: 'rgba8uint', baseArrayLayer: 0}); |
| try { |
| buffer27.unmap(); |
| } catch {} |
| let buffer87 = device0.createBuffer({ |
| size: 2581, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let texture124 = device0.createTexture({ |
| size: [2, 2, 13], |
| mipLevelCount: 1, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder107 = commandEncoder124.beginComputePass(); |
| try { |
| computePassEncoder90.setBindGroup(0, bindGroup17, new Uint32Array(3712), 1_195, 0); |
| } catch {} |
| try { |
| computePassEncoder107.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -77.14, g: 503.0, b: -879.2, a: 250.8, }); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline19); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| try { |
| computePassEncoder37.pushDebugGroup('\u{1fe0d}'); |
| } catch {} |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let textureView111 = texture124.createView({dimension: '2d', format: 'rgba8snorm', baseArrayLayer: 1}); |
| let sampler93 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', magFilter: 'nearest'}); |
| try { |
| computePassEncoder102.setBindGroup(1, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer77, 'uint16', 19_378, 4_751); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(6, buffer64, 0, 3_671); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer61, 1500, new Int16Array(18777), 1209, 220); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 4, y: 21, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(1).fill(113), /* required buffer size: 1 */ |
| {offset: 1, bytesPerRow: 26}, {width: 5, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer88 = device0.createBuffer({ |
| size: 10048, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView112 = texture32.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0}); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| let sampler94 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.00, |
| compare: 'equal', |
| }); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder86.setBindGroup(0, bindGroup31, new Uint32Array(71), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer86, 'uint16', 2_284, 6_195); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, undefined, 1_808_599_694); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(1, buffer64); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder5.insertDebugMarker('\u0b23'); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(3, bindGroup37, new Uint32Array(779), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setScissorRect(7, 1, 5, 1); |
| } catch {} |
| try { |
| renderPassEncoder30.setViewport(109.33540341327891, 36.058348201187854, 5.887908041008904, 0.1264247568168852, 0.6673026899388872, 0.9375298901480178); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer34, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer87, 'uint16', 70, 184); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(2, buffer8, 0, 406); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 2140, new DataView(new ArrayBuffer(9538)), 4989, 560); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas1); |
| await gc(); |
| let imageData20 = new ImageData(16, 104); |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup75 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer14, offset: 0, size: 1084}}], |
| }); |
| let textureView113 = texture124.createView({dimension: '2d', format: 'rgba8snorm', baseArrayLayer: 1}); |
| let textureView114 = texture48.createView({dimension: '1d'}); |
| let renderBundle14 = renderBundleEncoder14.finish({}); |
| let sampler95 = device0.createSampler({addressModeU: 'mirror-repeat', minFilter: 'nearest'}); |
| try { |
| computePassEncoder31.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder51.setBindGroup(0, bindGroup41, new Uint32Array(321), 36, 0); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout50 = pipeline3.getBindGroupLayout(0); |
| let buffer89 = device0.createBuffer({ |
| size: 1254, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let textureView115 = texture71.createView({mipLevelCount: 1, arrayLayerCount: 6}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup45); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer29, 'uint16', 3_258, 2_251); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(3, buffer64, 260, 36); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer26.unmap(); |
| } catch {} |
| let img2 = await imageWithData(32, 9, '#10101010', '#20202020'); |
| let videoFrame15 = new VideoFrame(imageBitmap2, {timestamp: 0}); |
| let autogeneratedBindGroupLayout51 = pipeline12.getBindGroupLayout(0); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup34, new Uint32Array(1520), 40, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(151); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer87, 'uint32', 584, 1_530); |
| } catch {} |
| try { |
| buffer38.unmap(); |
| } catch {} |
| let promise10 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{ |
| format: 'rgba8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilBack: {}, |
| stencilReadMask: 450636390, |
| stencilWriteMask: 238473436, |
| depthBias: -1773429811, |
| depthBiasSlopeScale: 902.9015600285811, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 624, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x2', offset: 24, shaderLocation: 5}, |
| {format: 'float32x3', offset: 204, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 56, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw'}, |
| }); |
| let imageData21 = new ImageData(20, 16); |
| try { |
| adapter0.label = '\u061e\u7cfd'; |
| } catch {} |
| let bindGroup76 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 8, resource: {buffer: buffer69, offset: 0}}], |
| }); |
| let buffer90 = device0.createBuffer({size: 1443, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder27.setBindGroup(3, bindGroup74, new Uint32Array(3245), 184, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'bt2020_12bit'} }); |
| let autogeneratedBindGroupLayout52 = pipeline23.getBindGroupLayout(0); |
| let bindGroup77 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [{binding: 53, resource: {buffer: buffer5, offset: 1024}}], |
| }); |
| let textureView116 = texture62.createView({}); |
| let sampler96 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'greater', |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder83.setBindGroup(2, bindGroup76); |
| } catch {} |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| await buffer51.mapAsync(GPUMapMode.WRITE, 1200, 8); |
| } catch {} |
| let imageData22 = new ImageData(80, 44); |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let renderPassEncoder34 = commandEncoder8.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| depthSlice: 9, |
| clearValue: { r: -141.3, g: -497.6, b: -68.81, a: 174.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView44, |
| depthClearValue: 0.9819984718965795, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'store', |
| stencilClearValue: 37630, |
| }, |
| }); |
| let sampler97 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 97.73}); |
| try { |
| computePassEncoder35.setBindGroup(0, bindGroup53, new Uint32Array(4270), 1_778, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer7, 204); }; |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer78, 'uint16', 1_282, 68); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline13); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| await gc(); |
| let commandEncoder126 = device0.createCommandEncoder({}); |
| let textureView117 = texture9.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 7}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle15 = renderBundleEncoder15.finish({}); |
| let sampler98 = device0.createSampler({addressModeV: 'repeat', minFilter: 'nearest', lodMaxClamp: 75.03}); |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup24); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer15, 732); }; |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setScissorRect(9, 0, 8, 2); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer21, 'uint16', 7_652, 24); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline22); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 1316, new Float32Array(28203), 36, 316); |
| } catch {} |
| await gc(); |
| let computePassEncoder108 = commandEncoder125.beginComputePass({}); |
| let renderPassEncoder35 = commandEncoder126.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: -219.1, g: -75.21, b: -173.5, a: -206.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder100.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder34.setBlendConstant({ r: 929.4, g: 425.6, b: 7.645, a: -252.1, }); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer40, 'uint16', 1_066, 4_607); |
| } catch {} |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| let textureView118 = texture89.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| let computePassEncoder109 = commandEncoder127.beginComputePass({}); |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder81.insertDebugMarker('\u06e9'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer85, 500, new DataView(new ArrayBuffer(8404)), 2585, 280); |
| } catch {} |
| let commandEncoder128 = device0.createCommandEncoder(); |
| let texture125 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 2}, |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder110 = commandEncoder128.beginComputePass({}); |
| try { |
| computePassEncoder63.setBindGroup(3, bindGroup45, new Uint32Array(1131), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.beginOcclusionQuery(14); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(7, buffer29, 0, 932); |
| } catch {} |
| let bindGroup78 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout20, |
| entries: [{binding: 8, resource: {buffer: buffer85, offset: 0}}], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer86, 3_228); }; |
| } catch {} |
| try { |
| computePassEncoder109.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder14.setBlendConstant({ r: 322.7, g: 493.4, b: 793.5, a: 869.9, }); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer85, 224, new Float32Array(35598), 5293, 0); |
| } catch {} |
| let pipeline27 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilFront: {}, |
| stencilReadMask: 485820707, |
| stencilWriteMask: 182783011, |
| depthBias: -2050829032, |
| depthBiasSlopeScale: 758.4282818954757, |
| }, |
| vertex: {module: shaderModule0, constants: {}, buffers: []}, |
| primitive: {frontFace: 'cw'}, |
| }); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let textureView119 = texture120.createView({baseMipLevel: 0}); |
| let computePassEncoder111 = commandEncoder129.beginComputePass({}); |
| let sampler99 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.98, |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup12, new Uint32Array(832), 246, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer80, 'uint32', 324, 4_773); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(7, buffer83, 704, 166); |
| } catch {} |
| let bindGroup79 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout33, |
| entries: [{binding: 216, resource: textureView38}, {binding: 8, resource: {buffer: buffer28, offset: 512}}], |
| }); |
| let commandEncoder130 = device0.createCommandEncoder(); |
| let textureView120 = texture105.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| let renderPassEncoder36 = commandEncoder130.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: 398.9, g: -872.0, b: -820.0, a: 354.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView44, depthReadOnly: true}, |
| }); |
| try { |
| computePassEncoder95.setBindGroup(1, bindGroup43, new Uint32Array(2153), 392, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer40, 'uint32', 5_168, 322); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(7, buffer83, 0); |
| } catch {} |
| let bindGroup80 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 8, resource: {buffer: buffer79, offset: 0, size: 100}}], |
| }); |
| let buffer91 = device0.createBuffer({size: 390, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| let texture126 = device0.createTexture({ |
| size: [240], |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder37 = commandEncoder131.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| depthSlice: 21, |
| clearValue: { r: 845.1, g: 596.9, b: 406.0, a: 736.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView20, depthClearValue: -4.811770165568667, depthLoadOp: 'load', depthStoreOp: 'store'}, |
| maxDrawCount: 540614247, |
| }); |
| try { |
| computePassEncoder50.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer61, 92); }; |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup80, new Uint32Array(1647), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBlendConstant({ r: -721.7, g: 152.2, b: -938.5, a: -744.1, }); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer62, 'uint32', 312, 7_059); |
| } catch {} |
| try { |
| buffer62.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 1176, new Int16Array(18073), 283, 1000); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup81 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout45, |
| entries: [{binding: 8, resource: {buffer: buffer50, offset: 0, size: 216}}], |
| }); |
| let commandEncoder132 = device0.createCommandEncoder({}); |
| let computePassEncoder112 = commandEncoder132.beginComputePass(); |
| let sampler100 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 59.91, |
| }); |
| try { |
| computePassEncoder111.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer62, 'uint16', 1_618, 786); |
| } catch {} |
| let pipeline28 = device0.createComputePipeline({layout: pipelineLayout8, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 32, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let commandEncoder133 = device0.createCommandEncoder({}); |
| let externalTexture16 = device0.importExternalTexture({label: '\ub43b\u{1fc1d}\u01ec\u7959\u9ef2\u016a\ubc5e\uf3c4\uf415\ufc4d\u1027', source: videoFrame11}); |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup12, new Uint32Array(1919), 124, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setViewport(94.79956566718174, 5.761032748892756, 20.99371760734585, 0.17201462834034092, 0.6527615485044552, 0.8651034772662964); |
| } catch {} |
| try { |
| buffer78.unmap(); |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [{binding: 8, resource: {buffer: buffer83, offset: 768, size: 3972}}], |
| }); |
| let buffer92 = device0.createBuffer({size: 478, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let renderPassEncoder38 = commandEncoder134.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView120, |
| clearValue: { r: 805.5, g: 337.7, b: -719.7, a: 245.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 40760579, |
| }); |
| try { |
| computePassEncoder73.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup61, new Uint32Array(493), 38, 0); |
| } catch {} |
| try { |
| computePassEncoder48.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer46, 'uint16', 494, 301); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline27); |
| } catch {} |
| try { |
| commandEncoder133.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2364 */ |
| offset: 2364, |
| bytesPerRow: 4864, |
| buffer: buffer31, |
| }, { |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup41, new Uint32Array(263), 131, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(754); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle0, renderBundle4, renderBundle2, renderBundle9, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer36, 'uint16', 256, 950); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer26, 532, new Float32Array(37436), 3473, 172); |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 39, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 261, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 303, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let computePassEncoder113 = commandEncoder133.beginComputePass({}); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup81); |
| } catch {} |
| try { |
| computePassEncoder64.setBindGroup(0, bindGroup48, new Uint32Array(1808), 105, 0); |
| } catch {} |
| try { |
| computePassEncoder112.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup64, new Uint32Array(1953), 772, 0); |
| } catch {} |
| let buffer93 = device0.createBuffer({size: 7172, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture127 = device0.createTexture({ |
| size: [240, 80, 1], |
| sampleCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView121 = texture78.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 2}); |
| let computePassEncoder114 = commandEncoder135.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer77, 1_980); }; |
| } catch {} |
| try { |
| computePassEncoder35.end(); |
| } catch {} |
| try { |
| renderPassEncoder36.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer80, 'uint32', 48, 567); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline23); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 8, new DataView(new ArrayBuffer(13556)), 3533, 0); |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 53, resource: {buffer: buffer62, offset: 2560, size: 3304}}], |
| }); |
| let computePassEncoder115 = commandEncoder41.beginComputePass({}); |
| try { |
| computePassEncoder114.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup59, new Uint32Array(578), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle1, renderBundle7, renderBundle8, renderBundle8, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer21, 'uint16', 1_934, 2_121); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline22); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 116, y: 7, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet16 = device0.createQuerySet({type: 'occlusion', count: 499}); |
| let texture128 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder108.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(2, bindGroup45, new Uint32Array(2166), 115, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(27); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer87, 'uint16', 304, 692); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(4, buffer7, 0, 625); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 2, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 216, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 2304}}], |
| }); |
| let buffer94 = device0.createBuffer({ |
| size: 485, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder136 = device0.createCommandEncoder(); |
| let computePassEncoder116 = commandEncoder136.beginComputePass({}); |
| try { |
| computePassEncoder113.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup53, new Uint32Array(1408), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer28, 'uint32', 476, 529); |
| } catch {} |
| try { |
| computePassEncoder112.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder25.setViewport(12.800250057323396, 25.336897165971777, 11.830119332132114, 1.0910023311180013, 0.7702941672349232, 0.8261737823616597); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 7, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(93).fill(89), /* required buffer size: 93 */ |
| {offset: 93, bytesPerRow: 77}, {width: 11, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({layout: autogeneratedBindGroupLayout44, entries: [{binding: 216, resource: textureView92}]}); |
| let buffer95 = device0.createBuffer({size: 7803, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture129 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView122 = texture28.createView({dimension: 'cube', aspect: 'all', format: 'rg11b10ufloat'}); |
| let computePassEncoder117 = commandEncoder48.beginComputePass({}); |
| try { |
| computePassEncoder78.setBindGroup(0, bindGroup58, new Uint32Array(569), 59, 0); |
| } catch {} |
| try { |
| computePassEncoder117.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer53, 'uint16', 6_360, 1_580); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(5, buffer80, 2_976); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let autogeneratedBindGroupLayout53 = pipeline16.getBindGroupLayout(0); |
| let buffer96 = device0.createBuffer({size: 20323, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView123 = texture109.createView({}); |
| let texture130 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler101 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.22, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup66, new Uint32Array(993), 61, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(3, bindGroup51, new Uint32Array(4895), 240, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setViewport(36.09642985191905, 0.35208353790811664, 7.493617476337307, 7.928608227671376, 0.9276106782549967, 0.9410328947278568); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(2, buffer79, 0, 135); |
| } catch {} |
| let arrayBuffer6 = buffer65.getMappedRange(368, 112); |
| let buffer97 = device0.createBuffer({ |
| size: 2754, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| let computePassEncoder118 = commandEncoder137.beginComputePass({}); |
| try { |
| computePassEncoder28.setBindGroup(2, bindGroup33); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup11, new Uint32Array(776), 79, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer78, 756, 901); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| document.body.append(canvas2); |
| try { |
| textureView43.label = '\u{1f70c}\ue522\u242a\u025a'; |
| } catch {} |
| let textureView124 = texture0.createView({dimension: '2d-array', baseArrayLayer: 2, arrayLayerCount: 2}); |
| try { |
| computePassEncoder110.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer62, 'uint32', 6_216, 2_842); |
| } catch {} |
| let arrayBuffer7 = buffer65.getMappedRange(488, 700); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let textureView125 = texture90.createView({}); |
| let computePassEncoder119 = commandEncoder138.beginComputePass(); |
| let sampler102 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| lodMaxClamp: 80.26, |
| }); |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup20, new Uint32Array(527), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setBlendConstant({ r: -123.3, g: -389.3, b: 880.9, a: -448.3, }); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(2, buffer9, 1_476); |
| } catch {} |
| await gc(); |
| let imageData23 = new ImageData(44, 48); |
| let autogeneratedBindGroupLayout54 = pipeline20.getBindGroupLayout(0); |
| let texture131 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView126 = texture25.createView({aspect: 'depth-only'}); |
| try { |
| computePassEncoder84.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup71); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup25, new Uint32Array(52), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(6); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder54.setBindGroup(2, bindGroup71, new Uint32Array(301), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle7, renderBundle5, renderBundle12, renderBundle2, renderBundle6, renderBundle1, renderBundle1, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer7, 0, 489); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let videoFrame17 = new VideoFrame(videoFrame11, {timestamp: 0}); |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 32, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let texture132 = device0.createTexture({ |
| size: [60, 20, 1], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder115.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer40, 'uint32', 5_312, 2_956); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 96, new Int16Array(4617), 31, 92); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(55, 44); |
| let buffer98 = device0.createBuffer({ |
| size: 3245, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder109.setBindGroup(0, bindGroup5, new Uint32Array(2422), 255, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(3, bindGroup78); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup15, new Uint32Array(3871), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle8, renderBundle1, renderBundle8, renderBundle2]); |
| } catch {} |
| try { |
| computePassEncoder37.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer96, 6996, new Int16Array(14230), 2803, 1064); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer99 = device0.createBuffer({size: 3625, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder32.setBindGroup(3, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder37.executeBundles([renderBundle1, renderBundle5, renderBundle9, renderBundle12, renderBundle1, renderBundle0]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 0, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 37, y: 70, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout55 = pipeline3.getBindGroupLayout(0); |
| let texture133 = gpuCanvasContext1.getCurrentTexture(); |
| let renderPassEncoder39 = commandEncoder140.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: 227.8, g: -417.8, b: 709.4, a: 205.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder108.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup69, new Uint32Array(269), 88, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup28, new Uint32Array(40), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(150); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder20.drawIndexedIndirect(buffer73, 148); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer64, 'uint32', 3_080, 2_387); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline22); |
| } catch {} |
| let promise13 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| document.body.append(img1); |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt709', transfer: 'iec61966-2-1'} }); |
| let commandEncoder141 = device0.createCommandEncoder(); |
| let querySet17 = device0.createQuerySet({type: 'occlusion', count: 294}); |
| let computePassEncoder120 = commandEncoder139.beginComputePass({}); |
| try { |
| computePassEncoder119.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(632); |
| } catch {} |
| try { |
| renderPassEncoder20.draw(126, 89, 1_064_289_164, 1_402_047_601); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(5, buffer87, 0); |
| } catch {} |
| try { |
| commandEncoder141.resolveQuerySet(querySet6, 146, 74, buffer46, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); }; |
| } catch {} |
| let textureView127 = texture10.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| let computePassEncoder121 = commandEncoder141.beginComputePass(); |
| try { |
| computePassEncoder99.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder20.drawIndexedIndirect(buffer4, 296); |
| } catch {} |
| try { |
| renderPassEncoder20.drawIndirect(buffer38, 400); |
| } catch {} |
| let recycledExplicitBindGroupLayout2 = pipeline5.getBindGroupLayout(0); |
| let buffer100 = device0.createBuffer({size: 21154, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder31.setBindGroup(2, bindGroup40, new Uint32Array(163), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.end(); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(4, buffer8); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer96, 8244, new Float32Array(2492), 301, 236); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture80, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(145).fill(231), /* required buffer size: 145 */ |
| {offset: 145}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer17, offset: 0, size: 464}}, |
| {binding: 258, resource: textureView84}, |
| ], |
| }); |
| let commandEncoder142 = device0.createCommandEncoder({}); |
| let computePassEncoder122 = commandEncoder75.beginComputePass({}); |
| let sampler103 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 72.93, |
| compare: 'never', |
| maxAnisotropy: 12, |
| }); |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(3, buffer55, 2_800); |
| } catch {} |
| try { |
| externalTexture14.label = '\uec88\u{1fe7f}\u0354\u{1faa4}\u1845\ub7f2\ufe20\ue4d0\u08d7\u093c\ua299'; |
| } catch {} |
| let buffer101 = device0.createBuffer({ |
| size: 8063, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView128 = texture62.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder50.setBindGroup(1, bindGroup45, new Uint32Array(2585), 260, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(2, undefined, 0, 454_237_800); |
| } catch {} |
| try { |
| buffer84.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| await gc(); |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 54, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout56 = pipeline27.getBindGroupLayout(0); |
| let textureView129 = texture74.createView({ |
| label: '\u5f1d\u608e\u0768\u5372\u85fe\u{1f87b}\u2920\ub2f9\u0ad7', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| }); |
| let computePassEncoder123 = commandEncoder142.beginComputePass(); |
| try { |
| computePassEncoder50.setBindGroup(3, bindGroup55); |
| } catch {} |
| try { |
| renderPassEncoder37.setScissorRect(2, 5, 5, 7); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer69, 'uint32', 280, 4); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(3, buffer50, 24); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(353).fill(70), /* required buffer size: 353 */ |
| {offset: 163, bytesPerRow: 38, rowsPerImage: 5}, {width: 0, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let gpuCanvasContext5 = offscreenCanvas2.getContext('webgpu'); |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let bindGroup87 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 8, resource: {buffer: buffer43, offset: 0, size: 492}}], |
| }); |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder143.resolveQuerySet(querySet5, 3, 75, buffer88, 1792); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame18, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 24, y: 22, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline29 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {}, |
| fragment: { |
| module: shaderModule1, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'never', |
| stencilReadMask: 993149734, |
| stencilWriteMask: 2045311569, |
| depthBias: -2134437771, |
| depthBiasSlopeScale: 190.57814241354845, |
| depthBiasClamp: 599.1309168820513, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 604, |
| attributes: [ |
| {format: 'float32x4', offset: 88, shaderLocation: 5}, |
| {format: 'snorm8x2', offset: 116, shaderLocation: 14}, |
| {format: 'float32x2', offset: 72, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw'}, |
| }); |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let computePassEncoder124 = commandEncoder143.beginComputePass({}); |
| try { |
| computePassEncoder71.setBindGroup(2, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder121.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer79, 0, 53); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let renderPassEncoder40 = commandEncoder144.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| depthSlice: 139, |
| clearValue: { r: -134.4, g: 865.2, b: 886.2, a: 545.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView20, |
| depthClearValue: 0.03582174841397456, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| stencilClearValue: 17369, |
| }, |
| maxDrawCount: 17822099, |
| }); |
| try { |
| computePassEncoder124.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup51); |
| } catch {} |
| let arrayBuffer8 = buffer51.getMappedRange(1200, 0); |
| let autogeneratedBindGroupLayout57 = pipeline17.getBindGroupLayout(0); |
| let querySet18 = device0.createQuerySet({type: 'occlusion', count: 651}); |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup75, new Uint32Array(1843), 1_049, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(121); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer82, 'uint32', 196, 840); |
| } catch {} |
| let pipeline30 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); }; |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(199, 33); |
| let imageData24 = new ImageData(120, 48); |
| let videoFrame19 = new VideoFrame(videoFrame6, {timestamp: 0}); |
| try { |
| offscreenCanvas3.getContext('bitmaprenderer'); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture15.label; |
| } catch {} |
| let autogeneratedBindGroupLayout58 = pipeline24.getBindGroupLayout(0); |
| let bindGroup88 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout21, |
| entries: [{binding: 8, resource: {buffer: buffer22, offset: 13824, size: 8304}}], |
| }); |
| let buffer102 = device0.createBuffer({size: 22970, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let texture134 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 92}, |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder118.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer46, 'uint32', 896, 26); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline29); |
| } catch {} |
| let texture135 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder5.executeBundles([renderBundle11, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer21, 'uint16', 214, 4_360); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(5, buffer98, 0, 133); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| struct S3 { |
| @location(13) f0: f32, |
| @location(8) f1: i32, |
| @builtin(instance_index) f2: u32, |
| @builtin(vertex_index) f3: u32, |
| @location(10) @interpolate(flat) f4: u32, |
| } |
| |
| @group(0) @binding(8) var<storage, read> buffer103: array<array<array<array<array<array<f16, 1>, 3>, 1>, 1>, 9>>; |
| |
| struct T1 { |
| @size(56) f0: array<u32>, |
| } |
| |
| fn fn1() -> array<vec2u, 1> { |
| var out: array<vec2u, 1>; |
| let ptr87: ptr<storage, f16, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][0][u32(unconst_u32(117))][2][0]; |
| let ptr88: ptr<storage, array<array<array<array<f16, 1>, 3>, 1>, 1>, read> = &buffer103[u32(unconst_u32(146))][8]; |
| let ptr89: ptr<storage, f16, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(176))][0][0][2][0]; |
| out[u32(unconst_u32(385))] <<= vec2u(u32(buffer103[arrayLength(&buffer103)][u32(unconst_u32(49))][u32((*&buffer103)[arrayLength(&(*&buffer103))][8][0][0][2][0])][0][2][0])); |
| out[u32(unconst_u32(145))] ^= vec2u(u32(buffer103[arrayLength(&buffer103)][8][u32(unconst_u32(93))][0][arrayLength(&(*&buffer103))][0])); |
| let ptr90: ptr<storage, array<f16, 1>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(75))][u32(unconst_u32(1))][0][u32(unconst_u32(286))]; |
| return out; |
| _ = buffer103; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn2() -> S3 { |
| var out: S3; |
| out.f2 *= u32((*&buffer103)[u32(buffer103[u32(unconst_u32(40))][8][u32(unconst_u32(165))][0][2][0])][u32(unconst_u32(200))][u32(unconst_u32(24))][0][2][0]); |
| let ptr91: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(10))][u32(unconst_u32(506))]; |
| let ptr92: ptr<storage, f16, read> = &buffer103[u32(unconst_u32(13))][u32(unconst_u32(338))][0][u32(unconst_u32(74))][u32(unconst_u32(349))][0]; |
| let ptr93: ptr<storage, array<array<f16, 1>, 3>, read> = &buffer103[u32(unconst_u32(237))][8][0][0]; |
| let ptr94: ptr<storage, array<array<array<f16, 1>, 3>, 1>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(331))][0]; |
| return out; |
| _ = buffer103; |
| } |
| |
| struct T2 { |
| @size(56) f0: u32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T3 { |
| @size(56) f0: array<u32>, |
| } |
| |
| struct T0 { |
| @size(56) f0: array<u32>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput2 { |
| @builtin(position) f4: vec4f, |
| @location(11) @interpolate(flat, centroid) f5: u32, |
| @location(14) @interpolate(flat, centroid) f6: vec2i, |
| } |
| |
| fn fn0() { |
| let ptr72: ptr<storage, array<f16, 1>, read> = &buffer103[u32(unconst_u32(229))][u32(unconst_u32(546))][u32(unconst_u32(340))][0][2]; |
| let ptr73: ptr<storage, array<f16, 1>, read> = &buffer103[u32(unconst_u32(1000))][u32(unconst_u32(236))][0][u32(unconst_u32(136))][u32((*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(257))][0][0][2][0])]; |
| let ptr74: ptr<storage, array<array<array<f16, 1>, 3>, 1>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][0]; |
| let ptr75: ptr<storage, f16, read> = &buffer103[u32(unconst_u32(10))][u32(unconst_u32(1000))][0][0][2][u32(unconst_u32(500))]; |
| let ptr76: ptr<storage, array<f16, 1>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(320))][u32(unconst_u32(149))][u32(buffer103[u32(unconst_u32(228))][8][0][0][2][u32(unconst_u32(53))])]; |
| let ptr77: ptr<storage, array<f16, 1>, read> = &(*&buffer103)[u32((*&buffer103)[arrayLength(&(*&buffer103))][8][0][u32(unconst_u32(186))][2][0])][u32(unconst_u32(35))][u32(unconst_u32(111))][u32(unconst_u32(19))][u32(unconst_u32(108))]; |
| let ptr78: ptr<storage, f16, read> = &(*&buffer103)[u32(unconst_u32(315))][u32(unconst_u32(27))][u32(unconst_u32(202))][0][2][u32(unconst_u32(95))]; |
| let ptr79: ptr<storage, f16, read> = &(*&buffer103)[u32(unconst_u32(24))][u32((*&buffer103)[u32(unconst_u32(124))][u32(unconst_u32(66))][0][0][2][0])][0][0][u32(unconst_u32(5))][u32(unconst_u32(214))]; |
| let ptr80: ptr<storage, array<f16, 1>, read> = &buffer103[u32(unconst_u32(82))][u32(unconst_u32(28))][u32(unconst_u32(258))][u32(unconst_u32(3))][2]; |
| let ptr81: ptr<storage, f16, read> = &buffer103[arrayLength(&buffer103)][u32(unconst_u32(223))][u32(unconst_u32(92))][0][u32(unconst_u32(303))][u32(unconst_u32(55))]; |
| let ptr82: ptr<storage, f16, read> = &(*ptr74)[0][2][u32(unconst_u32(16))]; |
| let ptr83: ptr<storage, array<array<array<array<f16, 1>, 3>, 1>, 1>, read> = &buffer103[arrayLength(&buffer103)][u32(unconst_u32(35))]; |
| let ptr84: ptr<storage, f16, read> = &(*ptr72)[0]; |
| let ptr85: ptr<storage, f16, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(194))][0][u32(unconst_u32(117))][2][0]; |
| let ptr86: ptr<storage, f16, read> = &buffer103[u32(unconst_u32(56))][u32(unconst_u32(80))][0][u32(unconst_u32(244))][2][u32(unconst_u32(4))]; |
| _ = buffer103; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentOutput4 { |
| @location(7) @interpolate(flat) f0: vec4u, |
| @location(0) @interpolate(flat, sample) f1: vec4u, |
| } |
| |
| @vertex @must_use |
| fn vertex3(@location(14) a0: vec4h, @location(7) @interpolate(linear, center) a1: vec4f, @location(5) a2: f32, a3: S3, @location(4) @interpolate(flat, centroid) a4: u32) -> VertexOutput2 { |
| var out: VertexOutput2; |
| var vf25 = fn2(); |
| let ptr95: ptr<storage, array<f16, 1>, read> = &buffer103[u32(unconst_u32(20))][u32(unconst_u32(67))][u32(unconst_u32(79))][0][u32(buffer103[u32((*&buffer103)[u32(unconst_u32(194))][8][u32(unconst_u32(174))][0][2][u32(unconst_u32(284))])][8][0][u32(unconst_u32(445))][u32(unconst_u32(101))][u32(unconst_u32(23))])]; |
| out = VertexOutput2(vec4f(f32((*&buffer103)[u32(unconst_u32(89))][8][u32(unconst_u32(354))][u32(unconst_u32(13))][2][0])), u32((*&buffer103)[u32(unconst_u32(89))][8][u32(unconst_u32(354))][u32(unconst_u32(13))][2][0]), vec2i(i32((*&buffer103)[u32(unconst_u32(89))][8][u32(unconst_u32(354))][u32(unconst_u32(13))][2][0]))); |
| out.f6 &= vec2i(i32((*&buffer103)[u32(unconst_u32(137))][8][u32(unconst_u32(69))][u32(unconst_u32(294))][2][0])); |
| return out; |
| _ = buffer103; |
| } |
| |
| @fragment |
| fn fragment4(@location(13) @interpolate(linear, sample) a0: vec2f, @location(0) a1: vec4h) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| let ptr96: ptr<storage, array<array<f16, 1>, 3>, read> = &buffer103[arrayLength(&buffer103)][8][u32(unconst_u32(87))][0]; |
| fn0(); |
| var vf26: vec3h = mix(vec3h(buffer103[u32(unconst_u32(214))][u32(unconst_u32(174))][0][0][2][0]), vec3h((*&buffer103)[u32(unconst_u32(80))][8][0][0][2][u32(unconst_u32(347))]), f16(unconst_f16(1400.5))); |
| out.f1 = unpack4xU8(u32(buffer103[u32(unconst_u32(60))][8][u32(unconst_u32(52))][0][2][0])); |
| fn0(); |
| out.f1 = unpack4xU8(u32(buffer103[arrayLength(&buffer103)][u32(unconst_u32(41))][0][0][2][u32((*&buffer103)[arrayLength(&(*&buffer103))][8][0][0][2][0])])); |
| let ptr97: ptr<storage, f16, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(167))][0][u32((*&buffer103)[u32(unconst_u32(85))][u32(unconst_u32(152))][0][0][2][u32(unconst_u32(13))])][u32(unconst_u32(70))]; |
| out.f0 += unpack4xU8(u32(buffer103[u32(unconst_u32(176))][8][u32(unconst_u32(168))][0][2][0])); |
| out.f0 = vec4u(u32(buffer103[u32(unconst_u32(206))][8][0][0][u32(unconst_u32(26))][u32(unconst_u32(28))])); |
| vf26 -= vec3h(buffer103[u32(unconst_u32(107))][8][u32(buffer103[u32(unconst_u32(4))][u32(unconst_u32(87))][0][u32(unconst_u32(398))][u32(unconst_u32(65))][0])][0][2][u32(unconst_u32(109))]); |
| let ptr98: ptr<storage, f16, read> = &(*ptr97); |
| let ptr99: ptr<storage, array<f16, 1>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][u32(buffer103[u32(unconst_u32(27))][8][0][0][2][0])][u32(unconst_u32(232))][2]; |
| fn0(); |
| out.f1 &= unpack4xU8(u32((*&buffer103)[u32((*&buffer103)[u32(unconst_u32(322))][u32(unconst_u32(69))][u32(unconst_u32(61))][0][2][u32(buffer103[u32(buffer103[u32((*&buffer103)[u32(unconst_u32(20))][u32(unconst_u32(31))][u32(unconst_u32(17))][u32(unconst_u32(179))][u32(unconst_u32(126))][0])][u32(unconst_u32(147))][u32((*ptr96)[2][0])][u32(unconst_u32(401))][2][0])][u32(unconst_u32(238))][u32(unconst_u32(245))][u32(unconst_u32(459))][u32(unconst_u32(31))][0])])][8][0][0][u32(unconst_u32(445))][0])); |
| out = FragmentOutput4(vec4u(u32(buffer103[u32(unconst_u32(295))][u32(buffer103[arrayLength(&buffer103)][u32(unconst_u32(23))][u32(unconst_u32(70))][u32(unconst_u32(644))][2][0])][u32(unconst_u32(199))][u32(unconst_u32(229))][2][0])), vec4u(u32(buffer103[u32(unconst_u32(295))][u32(buffer103[arrayLength(&buffer103)][u32(unconst_u32(23))][u32(unconst_u32(70))][u32(unconst_u32(644))][2][0])][u32(unconst_u32(199))][u32(unconst_u32(229))][2][0]))); |
| fn0(); |
| out.f0 *= vec4u(u32(buffer103[arrayLength(&buffer103)][u32(unconst_u32(141))][u32(unconst_u32(10))][0][2][u32(unconst_u32(290))])); |
| out.f1 &= unpack4xU8(u32(buffer103[arrayLength(&buffer103)][8][0][0][2][0])); |
| let ptr100: ptr<storage, f16, read> = &buffer103[u32(unconst_u32(200))][8][u32(unconst_u32(208))][u32((*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(57))][u32(unconst_u32(263))][2][0])][2][0]; |
| let ptr101: ptr<storage, f16, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(95))][u32(unconst_u32(440))][2][0]; |
| vf26 = vec3h((*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(86))][u32(unconst_u32(32))][u32(unconst_u32(36))][u32(unconst_u32(17))][u32(unconst_u32(200))]); |
| let ptr102: ptr<storage, f16, read> = &buffer103[arrayLength(&buffer103)][8][0][u32(unconst_u32(91))][u32((*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(28))][u32(unconst_u32(154))][0][2][0])][0]; |
| let ptr103: ptr<storage, array<f16, 1>, read> = &buffer103[u32(unconst_u32(784))][8][0][0][2]; |
| fn0(); |
| return out; |
| _ = buffer103; |
| } |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute4(@builtin(local_invocation_id) a0: vec3u) { |
| fn1(); |
| fn1(); |
| var vf27 = fn2(); |
| fn2(); |
| vf27.f0 = f32((*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(33))][u32(unconst_u32(386))][2][0]); |
| fn2(); |
| fn1(); |
| var vf28 = fn1(); |
| vf28[u32(unconst_u32(33))] = vec2u(u32((*&buffer103)[arrayLength(&(*&buffer103))][u32(unconst_u32(364))][u32(unconst_u32(305))][u32(unconst_u32(860))][u32(unconst_u32(292))][0])); |
| var vf29 = fn1(); |
| fn1(); |
| fn2(); |
| vf28[u32(unconst_u32(212))] -= vec2u(u32(buffer103[u32(unconst_u32(71))][8][u32(unconst_u32(175))][0][u32(unconst_u32(655))][0])); |
| vf29[0] |= vec2u(u32((*&buffer103)[arrayLength(&(*&buffer103))][8][0][u32(unconst_u32(186))][2][u32(unconst_u32(120))])); |
| fn1(); |
| let vf30: vec3h = faceForward(vec3h(unconst_f16(-808.6), unconst_f16(3017.9), unconst_f16(22135.4)), vec3h(unconst_f16(6195.2), unconst_f16(13149.8), unconst_f16(12987.9)), vec3h(unconst_f16(-45512.5), unconst_f16(1039.0), unconst_f16(16144.6))); |
| vf28[vec3u(inverseSqrt(vec3f(unconst_f32(0.2119), unconst_f32(0.5364), unconst_f32(0.03011))))[1]] -= vec2u(u32(buffer103[u32(unconst_u32(11))][8][u32(unconst_u32(44))][u32((*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(124))][0][2][0])][u32(unconst_u32(46))][0])); |
| _ = buffer103; |
| } |
| |
| @compute @workgroup_size(8, 1, 1) |
| fn compute5() { |
| let ptr104: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer103)[arrayLength(&(*&buffer103))][8][u32(unconst_u32(81))][0]; |
| var vf31 = fn1(); |
| _ = buffer103; |
| }`, |
| }); |
| let querySet19 = device0.createQuerySet({type: 'occlusion', count: 145}); |
| let texture136 = device0.createTexture({ |
| size: [30, 10, 10], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup10, []); |
| } catch {} |
| try { |
| computePassEncoder122.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(2, bindGroup64, new Uint32Array(693), 234, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 72, new Int16Array(8537), 1309, 180); |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 8, resource: {buffer: buffer46, offset: 512, size: 280}}], |
| }); |
| try { |
| computePassEncoder116.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer62, 'uint16', 9_858, 3_549); |
| } catch {} |
| let pipeline31 = await promise13; |
| let autogeneratedBindGroupLayout59 = pipeline24.getBindGroupLayout(0); |
| let textureView130 = texture65.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 1}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let renderBundle16 = renderBundleEncoder16.finish({}); |
| try { |
| computePassEncoder78.setBindGroup(2, bindGroup6, new Uint32Array(47), 7, 0); |
| } catch {} |
| try { |
| computePassEncoder123.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer94, 'uint32', 168, 2); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture117, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(6).fill(30), /* required buffer size: 6 */ |
| {offset: 6, bytesPerRow: 48, rowsPerImage: 18}, {width: 1, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer104 = device0.createBuffer({ |
| size: 7446, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let querySet20 = device0.createQuerySet({type: 'occlusion', count: 2292}); |
| let texture137 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView131 = texture137.createView({dimension: '2d-array'}); |
| let renderPassEncoder41 = commandEncoder145.beginRenderPass({ |
| colorAttachments: [{view: textureView41, depthSlice: 33, loadOp: 'clear', storeOp: 'discard'}], |
| depthStencilAttachment: {view: textureView23, depthClearValue: -4.706338721921995, depthLoadOp: 'load', depthStoreOp: 'store'}, |
| }); |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup87, []); |
| } catch {} |
| try { |
| computePassEncoder120.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer34, 0, 3_387); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| document.body.prepend(canvas1); |
| let texture138 = device0.createTexture({size: [240, 80, 1], format: 'depth32float', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let sampler104 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 53.97, compare: 'less-equal'}); |
| try { |
| computePassEncoder63.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(2, buffer40, 716, 5_719); |
| } catch {} |
| try { |
| buffer81.unmap(); |
| } catch {} |
| let buffer105 = device0.createBuffer({ |
| size: 5182, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX, |
| mappedAtCreation: false, |
| }); |
| let texture139 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView132 = texture27.createView({aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1}); |
| let sampler105 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder106.setBindGroup(1, bindGroup85, new Uint32Array(4059), 820, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer24, 'uint32', 4_740, 6_033); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout56, |
| entries: [{binding: 8, resource: {buffer: buffer54, offset: 768, size: 840}}], |
| }); |
| let textureView133 = texture52.createView({arrayLayerCount: 1}); |
| let sampler106 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 97.53}); |
| try { |
| renderPassEncoder12.pushDebugGroup('\u0753'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipeline32 = await promise10; |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer106 = device0.createBuffer({size: 29, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder146 = device0.createCommandEncoder(); |
| let sampler107 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMinClamp: 40.95, |
| lodMaxClamp: 41.83, |
| }); |
| try { |
| computePassEncoder72.setBindGroup(3, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle3, renderBundle7, renderBundle13, renderBundle8]); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 1, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 108, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 10, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout60 = pipeline4.getBindGroupLayout(0); |
| let textureView134 = texture0.createView({dimension: '2d', baseArrayLayer: 5}); |
| let computePassEncoder125 = commandEncoder146.beginComputePass({}); |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup5, new Uint32Array(588), 8, 0); |
| } catch {} |
| try { |
| buffer102.unmap(); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| let recycledExplicitBindGroupLayout3 = pipeline5.getBindGroupLayout(0); |
| let commandEncoder147 = device0.createCommandEncoder(); |
| let computePassEncoder126 = commandEncoder147.beginComputePass({}); |
| try { |
| computePassEncoder126.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup30, new Uint32Array(1241), 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(101, 23, 1_635_267_246, 641_110_838); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer14, 92); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer8, 'uint16', 316, 1_384); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline19); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let autogeneratedBindGroupLayout61 = pipeline26.getBindGroupLayout(0); |
| let texture140 = device0.createTexture({size: [60, 20, 31], format: 'rgba8sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(25, 7, 1_988_339_113, 3_976_282); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer23, 752); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(1, buffer76, 0, 4_306); |
| } catch {} |
| try { |
| renderPassEncoder12.popDebugGroup(); |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder148 = device0.createCommandEncoder(); |
| let textureView135 = texture52.createView({label: '\uf994\u0d5e\u95dd\u00cd\uce8b\u0271', arrayLayerCount: 1}); |
| let textureView136 = texture113.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(3, bindGroup17, []); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(92, 91, 400_029_846, 377_989_611); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer0, 668); |
| } catch {} |
| try { |
| renderPassEncoder14.pushDebugGroup('\u0e5e'); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder149 = device0.createCommandEncoder(); |
| let sampler108 = device0.createSampler({lodMaxClamp: 76.75}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer15, 884); }; |
| } catch {} |
| try { |
| computePassEncoder125.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(65, 93, 2_055_086_372, 852_244_541); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer102, 492); |
| } catch {} |
| try { |
| commandEncoder42.clearBuffer(buffer2, 32, 16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 2336, new Int16Array(17418), 4961, 540); |
| } catch {} |
| await gc(); |
| try { |
| externalTexture3.label = '\u2079\u{1f7e0}'; |
| } catch {} |
| let texture141 = device0.createTexture({ |
| size: [120, 40, 1], |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture142 = device0.createTexture({ |
| size: {width: 240}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder127 = commandEncoder42.beginComputePass({}); |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup35, new Uint32Array(232), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer88, 'uint16', 374, 2_388); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline13); |
| } catch {} |
| try { |
| commandEncoder149.copyBufferToTexture({ |
| /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2704 */ |
| offset: 2704, |
| bytesPerRow: 15616, |
| buffer: buffer59, |
| }, { |
| texture: texture99, |
| mipLevel: 0, |
| origin: {x: 8, y: 7, z: 0}, |
| aspect: 'all', |
| }, {width: 18, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView137 = texture141.createView({dimension: '2d-array'}); |
| let texture143 = device0.createTexture({ |
| size: {width: 240}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView138 = texture124.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 6}); |
| let computePassEncoder128 = commandEncoder148.beginComputePass({}); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| let renderBundle17 = renderBundleEncoder17.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder128.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(140, 122, 219_924_833, 337_158_021); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer53, 'uint16', 420, 6_163); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer24, 0); |
| } catch {} |
| let arrayBuffer9 = buffer1.getMappedRange(64, 8); |
| let pipeline33 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule3, |
| targets: [{ |
| format: 'rgba8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'always', |
| stencilBack: {depthFailOp: 'keep'}, |
| stencilWriteMask: 425950104, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 568, |
| attributes: [ |
| {format: 'float32', offset: 12, shaderLocation: 4}, |
| {format: 'float16x2', offset: 60, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 40, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x4', offset: 16, shaderLocation: 14}], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let buffer107 = device0.createBuffer({ |
| size: 809, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture144 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 25}, |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder42 = commandEncoder149.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: -990.2, g: -630.3, b: 487.8, a: 156.1, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView130, depthReadOnly: true}, |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 78407087, |
| }); |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup8, []); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(1, bindGroup57, new Uint32Array(3512), 93, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBlendConstant({ r: -560.0, g: 250.1, b: -67.11, a: -967.5, }); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer53, 'uint16', 188, 521); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer38, 1_044, 139); |
| } catch {} |
| try { |
| buffer101.unmap(); |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 8, resource: {buffer: buffer17, offset: 0}}], |
| }); |
| let texture145 = device0.createTexture({ |
| size: {width: 240}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder91.setBindGroup(2, bindGroup49, new Uint32Array(2282), 161, 0); |
| } catch {} |
| try { |
| computePassEncoder127.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup8, new Uint32Array(884), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle17, renderBundle14]); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer82, 140); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(4, buffer102, 3_584, 9_757); |
| } catch {} |
| try { |
| await buffer75.mapAsync(GPUMapMode.READ, 168, 1896); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 1, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 33, y: 33, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledAutogeneratedBindGroupLayout0 = pipeline30.getBindGroupLayout(0); |
| let bindGroup92 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout41, |
| entries: [{binding: 8, resource: {buffer: buffer32, offset: 4608, size: 936}}], |
| }); |
| let textureView139 = texture24.createView({dimension: '2d', baseArrayLayer: 3}); |
| let texture146 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView140 = texture141.createView({dimension: '2d-array'}); |
| let sampler109 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder78.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup53, new Uint32Array(1650), 83, 0); |
| } catch {} |
| try { |
| computePassEncoder93.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(2, bindGroup22, new Uint32Array(1377), 346, 0); |
| } catch {} |
| try { |
| buffer86.unmap(); |
| } catch {} |
| await gc(); |
| let bindGroup93 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout59, |
| entries: [{binding: 8, resource: {buffer: buffer86, offset: 256, size: 6028}}], |
| }); |
| let commandEncoder150 = device0.createCommandEncoder(); |
| let texture147 = device0.createTexture({ |
| size: {width: 1, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView141 = texture81.createView({ |
| label: '\u7ecd\u{1f9a0}\u0893\u6e58\u3c45\u5a32\u0bfa\u{1fd90}', |
| mipLevelCount: 2, |
| baseArrayLayer: 6, |
| arrayLayerCount: 2, |
| }); |
| let computePassEncoder129 = commandEncoder150.beginComputePass({}); |
| try { |
| computePassEncoder129.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(266, 295, 593_676_204, 497_426_462); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer40, 2_856); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer21, 'uint16', 2_126, 2_676); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 4, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 3, y: 23, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData25 = new ImageData(4, 84); |
| let bindGroup94 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout46, |
| entries: [{binding: 8, resource: {buffer: buffer39, offset: 1792, size: 360}}], |
| }); |
| let commandEncoder151 = device0.createCommandEncoder({}); |
| let textureView142 = texture147.createView({}); |
| let textureView143 = texture111.createView({dimension: '2d-array'}); |
| let computePassEncoder130 = commandEncoder151.beginComputePass({}); |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup69); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| let autogeneratedBindGroupLayout62 = pipeline31.getBindGroupLayout(0); |
| let pipelineLayout9 = device0.createPipelineLayout({ |
| label: '\u056b\u{1fcd3}\u0521\u{1fe50}\udd36\u8764\ud9ac\u{1ffd8}\u6f09\u0b22', |
| bindGroupLayouts: [veryExplicitBindGroupLayout3], |
| }); |
| let commandEncoder152 = device0.createCommandEncoder(); |
| let texture148 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView144 = texture54.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| let computePassEncoder131 = commandEncoder152.beginComputePass({}); |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer32, 3_824); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 276, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'unspecified'} }); |
| let bindGroup95 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout28, |
| entries: [{binding: 8, resource: {buffer: buffer61, offset: 512, size: 84}}], |
| }); |
| let textureView145 = texture129.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture149 = device0.createTexture({ |
| size: {width: 240}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView146 = texture24.createView({format: 'r32uint', baseArrayLayer: 2, arrayLayerCount: 5}); |
| try { |
| computePassEncoder131.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer36, 'uint32', 388, 248); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline19); |
| } catch {} |
| let imageData26 = new ImageData(4, 112); |
| let recycledExplicitBindGroupLayout4 = pipeline25.getBindGroupLayout(0); |
| let bindGroup96 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout36, |
| entries: [{binding: 8, resource: {buffer: buffer83, offset: 1792, size: 260}}], |
| }); |
| let sampler110 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMaxClamp: 91.07}); |
| try { |
| computePassEncoder37.end(); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline14); |
| } catch {} |
| try { |
| computePassEncoder130.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(3, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(0, bindGroup31, new Uint32Array(9858), 463, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setScissorRect(25, 0, 20, 17); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(204, 394, 1_305_067_447, 470_166_578); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer41, 968); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline12); |
| } catch {} |
| let pipeline34 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, entryPoint: 'fragment1', targets: [{format: 'rgba8sint', writeMask: 0}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilBack: {depthFailOp: 'keep'}, |
| stencilReadMask: 710325391, |
| depthBias: -1827395533, |
| }, |
| vertex: { |
| module: shaderModule3, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 16, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x2', offset: 4, shaderLocation: 5}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 14}, |
| {format: 'float32x3', offset: 0, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 4}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 9}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 3}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 12}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 15}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 6}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 13}, |
| {format: 'float32x4', offset: 0, shaderLocation: 10}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 2}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 8}, |
| ], |
| }, |
| { |
| arrayStride: 80, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32x4', offset: 12, shaderLocation: 11}], |
| }, |
| ], |
| }, |
| }); |
| let commandBuffer14 = commandEncoder44.finish({}); |
| let texture150 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 54}, |
| dimension: '2d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture151 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 294}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler111 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 84.60, |
| lodMaxClamp: 94.69, |
| }); |
| try { |
| renderPassEncoder19.beginOcclusionQuery(15); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer21, 'uint16', 1_268, 5_706); |
| } catch {} |
| try { |
| renderPassEncoder14.popDebugGroup(); |
| } catch {} |
| let autogeneratedBindGroupLayout63 = pipeline3.getBindGroupLayout(0); |
| let bindGroup97 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer8, offset: 256, size: 360}}], |
| }); |
| let sampler112 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', magFilter: 'linear', lodMaxClamp: 88.20}); |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder17.setStencilReference(14); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(229, 160, 17_932_566, 49_890_030); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer107, 60); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer72, 'uint16', 504, 142); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(5, buffer78, 108, 466); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout64 = pipeline26.getBindGroupLayout(0); |
| let commandEncoder153 = device0.createCommandEncoder({}); |
| let computePassEncoder132 = commandEncoder153.beginComputePass({}); |
| try { |
| computePassEncoder80.setBindGroup(1, bindGroup23, new Uint32Array(119), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder132.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderPassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer64); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 54, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout65 = pipeline8.getBindGroupLayout(0); |
| let bindGroup98 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout52, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 2304, size: 272}}], |
| }); |
| let commandBuffer15 = commandEncoder34.finish(); |
| let texture152 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler113 = device0.createSampler({addressModeU: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear', compare: 'greater-equal'}); |
| try { |
| computePassEncoder106.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(7, buffer102, 0, 3_756); |
| } catch {} |
| try { |
| renderPassEncoder23.insertDebugMarker('\u05dc'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer35, 156, new Int16Array(3771), 1141, 76); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let imageData27 = new ImageData(4, 36); |
| let buffer108 = device0.createBuffer({ |
| size: 4573, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup9, new Uint32Array(706), 494, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup71); |
| } catch {} |
| try { |
| renderPassEncoder42.beginOcclusionQuery(626); |
| } catch {} |
| try { |
| renderPassEncoder42.endOcclusionQuery(); |
| } catch {} |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let renderPassEncoder43 = commandEncoder154.beginRenderPass({ |
| label: '\u06d0\u{1fb77}\u0696\u0b57', |
| colorAttachments: [{view: textureView71, loadOp: 'clear', storeOp: 'store'}], |
| }); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame18}); |
| try { |
| computePassEncoder114.setBindGroup(2, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup41, new Uint32Array(2526), 1_071, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline32); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer26, 880, new DataView(new ArrayBuffer(62061)), 2486, 580); |
| } catch {} |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt2020', transfer: 'iec6196624'} }); |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let computePassEncoder133 = commandEncoder155.beginComputePass({}); |
| try { |
| computePassEncoder80.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder133.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder21.beginOcclusionQuery(269); |
| } catch {} |
| await gc(); |
| let bindGroup99 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 8, resource: {buffer: buffer43, offset: 512, size: 400}}], |
| }); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderPassEncoder27.executeBundles([renderBundle14]); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer80, 'uint16', 42, 569); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(6, buffer69, 32); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup39, new Uint32Array(682), 98, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline27); |
| } catch {} |
| let arrayBuffer10 = buffer65.getMappedRange(480, 0); |
| try { |
| buffer104.unmap(); |
| } catch {} |
| let bindGroup100 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout49, |
| entries: [{binding: 8, resource: {buffer: buffer61, offset: 256, size: 212}}], |
| }); |
| let buffer109 = device0.createBuffer({ |
| size: 82, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture153 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 59}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle18 = renderBundleEncoder18.finish({}); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder125.setBindGroup(2, bindGroup94); |
| } catch {} |
| try { |
| computePassEncoder120.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(64); |
| } catch {} |
| try { |
| computePassEncoder111.insertDebugMarker('\u07cd'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer45, 696, new Int16Array(1446), 163, 36); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let bindGroup101 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout23, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 1792}}], |
| }); |
| let buffer110 = device0.createBuffer({size: 40709, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let texture154 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer83, 'uint32', 28, 375); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(223).fill(146), /* required buffer size: 223 */ |
| {offset: 223, bytesPerRow: 135}, {width: 60, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer111 = device0.createBuffer({size: 14870, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture155 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder41.setPipeline(pipeline24); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let buffer112 = device0.createBuffer({ |
| size: 3205, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| let textureView147 = texture82.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer77, 'uint32', 148, 2_515); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline24); |
| } catch {} |
| try { |
| buffer108.unmap(); |
| } catch {} |
| let imageBitmap5 = await createImageBitmap(videoFrame9); |
| let bindGroup102 = device0.createBindGroup({ |
| layout: recycledAutogeneratedBindGroupLayout0, |
| entries: [{binding: 8, resource: {buffer: buffer86, offset: 5120}}], |
| }); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let texture156 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderPassEncoder28.insertDebugMarker('\u0eb4'); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let renderPassEncoder44 = commandEncoder157.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: -131.8, g: 508.4, b: 680.9, a: -83.95, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 260005638, |
| }); |
| let sampler114 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 96.48, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(60); |
| } catch {} |
| let pipeline35 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| let imageData28 = new ImageData(76, 96); |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| let sampler115 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest'}); |
| try { |
| computePassEncoder111.setBindGroup(3, bindGroup35, new Uint32Array(2139), 94, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup71, []); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(3, buffer19, 4_960, 473); |
| } catch {} |
| try { |
| commandEncoder156.insertDebugMarker('\u611b'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer30, 256, new Float32Array(1458), 212, 8); |
| } catch {} |
| await gc(); |
| let imageData29 = new ImageData(40, 80); |
| let autogeneratedBindGroupLayout66 = pipeline20.getBindGroupLayout(0); |
| let computePassEncoder134 = commandEncoder158.beginComputePass({}); |
| let sampler116 = device0.createSampler({addressModeV: 'repeat', magFilter: 'linear', lodMaxClamp: 99.85}); |
| try { |
| renderPassEncoder44.executeBundles([renderBundle17]); |
| } catch {} |
| try { |
| renderPassEncoder16.setStencilReference(306); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer72, 'uint32', 1_760, 126); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(6, buffer9); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout67 = pipeline20.getBindGroupLayout(0); |
| let texture157 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 147}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder45 = commandEncoder156.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: -179.5, g: -332.6, b: -268.8, a: -173.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 511108445, |
| }); |
| let renderBundle19 = renderBundleEncoder19.finish({}); |
| try { |
| computePassEncoder134.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup20); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture156, |
| mipLevel: 0, |
| origin: {x: 2, y: 9, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(245).fill(58), /* required buffer size: 245 */ |
| {offset: 245}, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise17 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| constants: {29_819: 0, 49_292: 0}, |
| targets: [{ |
| format: 'rgba8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilReadMask: 178016935, |
| stencilWriteMask: 710340969, |
| depthBias: -1479387667, |
| depthBiasSlopeScale: 655.959541229983, |
| depthBiasClamp: 710.8896571970527, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 108, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x2', offset: 0, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x2', offset: 12, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'back'}, |
| }); |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 238, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| let computePassEncoder135 = commandEncoder159.beginComputePass({}); |
| let sampler117 = device0.createSampler({addressModeW: 'repeat', magFilter: 'nearest'}); |
| try { |
| computePassEncoder80.setBindGroup(3, bindGroup96, []); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder36.executeBundles([renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(2, buffer70, 0, 943); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer40, 1668, new BigUint64Array(2428), 600, 908); |
| } catch {} |
| let textureView148 = texture64.createView({}); |
| try { |
| computePassEncoder39.setBindGroup(0, bindGroup5, new Uint32Array(920), 181, 0); |
| } catch {} |
| try { |
| computePassEncoder135.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(0, bindGroup90, new Uint32Array(1299), 200, 0); |
| } catch {} |
| try { |
| buffer88.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout68 = pipeline17.getBindGroupLayout(0); |
| let buffer113 = device0.createBuffer({ |
| size: 55732, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| }); |
| let textureView149 = texture150.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 7, arrayLayerCount: 1}); |
| let texture158 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView150 = texture121.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 2}); |
| try { |
| renderPassEncoder41.setBindGroup(0, bindGroup93, new Uint32Array(948), 3, 0); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let bindGroup103 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout7, |
| entries: [{binding: 8, resource: {buffer: buffer86, offset: 16128}}], |
| }); |
| let buffer114 = device0.createBuffer({size: 1623, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let sampler118 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder40.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder41.draw(123, 65, 682_957_993, 410_023_912); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer48, 104); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer69); |
| } catch {} |
| let promise18 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4, entryPoint: 'compute5'}}); |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let computePassEncoder136 = commandEncoder160.beginComputePass({}); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame15, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder19.executeBundles([renderBundle7, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder41.draw(47, 124, 305_063_567, 685_771_575); |
| } catch {} |
| try { |
| buffer40.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let imageData30 = new ImageData(52, 16); |
| let recycledAutogeneratedBindGroupLayout1 = pipeline35.getBindGroupLayout(0); |
| let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout21]}); |
| let querySet21 = device0.createQuerySet({type: 'occlusion', count: 121}); |
| let texture159 = device0.createTexture({ |
| size: [30, 10, 122], |
| sampleCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder136.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup92); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup34, new Uint32Array(1372), 341, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer77, 1_664); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(7, buffer64, 4_188, 569); |
| } catch {} |
| let querySet22 = device0.createQuerySet({type: 'occlusion', count: 1395}); |
| let texture160 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView151 = texture86.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| let renderBundle20 = renderBundleEncoder20.finish({}); |
| try { |
| renderPassEncoder45.setBindGroup(0, bindGroup13, new Uint32Array(221), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.executeBundles([renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer87, 820); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(3, buffer29, 192, 1_148); |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'unspecified', transfer: 'logSqrt'} }); |
| let texture161 = device0.createTexture({ |
| size: [2, 2, 3], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame21}); |
| try { |
| computePassEncoder79.setBindGroup(1, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup78); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle13]); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer7, 2_336); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 14, y: 7 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 22, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer115 = device0.createBuffer({ |
| size: 4866, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder131.setBindGroup(0, bindGroup55); |
| } catch {} |
| try { |
| computePassEncoder135.setBindGroup(3, bindGroup20, new Uint32Array(466), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.draw(186, 42, 1_018_997_133, 592_490_016); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer77, 0, 996); |
| } catch {} |
| try { |
| buffer45.unmap(); |
| } catch {} |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| let texture162 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder46 = commandEncoder161.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -317.5, g: 663.5, b: -938.9, a: -112.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder131); computePassEncoder131.dispatchWorkgroupsIndirect(buffer12, 4_728); }; |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(2, bindGroup36, new Uint32Array(1502), 64, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(0, buffer62, 0, 2_586); |
| } catch {} |
| offscreenCanvas1.width = 1220; |
| let imageData31 = new ImageData(20, 12); |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470m', transfer: 'log'} }); |
| try { |
| globalThis.someLabel = textureView55.label; |
| } catch {} |
| let textureView152 = texture104.createView({format: 'rgb10a2uint', arrayLayerCount: 1}); |
| try { |
| computePassEncoder103.setBindGroup(2, bindGroup31, new Uint32Array(714), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer9, 'uint16', 520, 3_837); |
| } catch {} |
| let autogeneratedBindGroupLayout69 = pipeline18.getBindGroupLayout(0); |
| try { |
| computePassEncoder96.setBindGroup(2, bindGroup88, new Uint32Array(238), 127, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.draw(54, 6, 94_915_290, 210_813_311); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer7, 1_992); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 179, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView153 = texture82.createView({dimension: '1d'}); |
| try { |
| computePassEncoder85.setBindGroup(0, bindGroup78, new Uint32Array(1), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder131.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup48, new Uint32Array(166), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer89, 24); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline23); |
| } catch {} |
| let pipeline36 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule1}}); |
| let bindGroup104 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout60, |
| entries: [{binding: 8, resource: {buffer: buffer79, offset: 0, size: 60}}], |
| }); |
| let computePassEncoder137 = commandEncoder152.beginComputePass({}); |
| let sampler119 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 74.44}); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder41.draw(7, 173, 872_513_712, 811_078_048); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer85, 416); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(0, buffer64, 1_896, 3_218); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame18, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 106, y: 44, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout70 = pipeline1.getBindGroupLayout(0); |
| let texture163 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture164 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 78}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true, stencilReadOnly: true}); |
| let sampler120 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 66.73, |
| maxAnisotropy: 14, |
| }); |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer61, 80); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(6, buffer64, 3_468, 877); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(3, bindGroup78, new Uint32Array(1027), 572, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer98, 'uint32', 12, 558); |
| } catch {} |
| let pipeline37 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule0}}); |
| try { |
| await promise15; |
| } catch {} |
| let bindGroup105 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout20, |
| entries: [{binding: 8, resource: {buffer: buffer46, offset: 0, size: 436}}], |
| }); |
| let texture165 = device0.createTexture({ |
| size: {width: 30}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler121 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 88.93}); |
| try { |
| computePassEncoder137.setBindGroup(1, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder137.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup104); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup59, new Uint32Array(1449), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.end(); |
| } catch {} |
| let arrayBuffer11 = buffer1.getMappedRange(72, 0); |
| let commandBuffer16 = commandEncoder145.finish({}); |
| let textureView154 = texture61.createView({dimension: 'cube'}); |
| let textureView155 = texture65.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 15}); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle20, renderBundle8, renderBundle4, renderBundle7, renderBundle16]); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| let autogeneratedBindGroupLayout71 = pipeline0.getBindGroupLayout(0); |
| let bindGroup106 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout32, |
| entries: [{binding: 8, resource: {buffer: buffer77, offset: 9728}}], |
| }); |
| let buffer116 = device0.createBuffer({ |
| size: 2748, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView156 = texture165.createView({}); |
| let textureView157 = texture132.createView({}); |
| let renderBundle21 = renderBundleEncoder21.finish(); |
| try { |
| computePassEncoder102.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(3, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup34, new Uint32Array(542), 80, 0); |
| } catch {} |
| document.body.prepend(img0); |
| let commandEncoder162 = device0.createCommandEncoder({}); |
| let computePassEncoder138 = commandEncoder162.beginComputePass({}); |
| try { |
| computePassEncoder90.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder138.setPipeline(pipeline25); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(img0); |
| let autogeneratedBindGroupLayout72 = pipeline10.getBindGroupLayout(0); |
| let buffer117 = device0.createBuffer({size: 995, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let querySet23 = device0.createQuerySet({type: 'occlusion', count: 266}); |
| let texture166 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 294}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView158 = texture87.createView({dimension: '2d', aspect: 'depth-only'}); |
| let sampler122 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 94.26, compare: 'not-equal'}); |
| let externalTexture23 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder58.setBindGroup(2, bindGroup82, new Uint32Array(1669), 628, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup104); |
| } catch {} |
| try { |
| renderPassEncoder46.executeBundles([renderBundle15, renderBundle14, renderBundle14, renderBundle14, renderBundle10, renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder44.setStencilReference(48); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder35.insertDebugMarker('\u2a01'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 988, new Float32Array(747), 13, 104); |
| } catch {} |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| let texture167 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView159 = texture40.createView({dimension: '2d'}); |
| let computePassEncoder139 = commandEncoder163.beginComputePass({}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup75); |
| } catch {} |
| try { |
| computePassEncoder139.setPipeline(pipeline35); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer104.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 5352, new Int16Array(5193), 329); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData29, |
| origin: { x: 1, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 175, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup107 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [{binding: 32, resource: {buffer: buffer115, offset: 0, size: 860}}], |
| }); |
| let buffer118 = device0.createBuffer({ |
| size: 38651, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let querySet24 = device0.createQuerySet({type: 'occlusion', count: 538}); |
| let sampler123 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 80.30, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(3, bindGroup80, new Uint32Array(366), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer107, 'uint16', 20, 38); |
| } catch {} |
| let recycledExplicitBindGroupLayout5 = pipeline25.getBindGroupLayout(1); |
| let buffer119 = device0.createBuffer({ |
| size: 8608, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture168 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView160 = texture126.createView({}); |
| try { |
| computePassEncoder111.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(0, bindGroup98); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup48, new Uint32Array(1384), 798, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer115, 'uint16', 1_326, 1_774); |
| } catch {} |
| let pipeline38 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4, entryPoint: 'compute4', constants: {}}}); |
| let buffer120 = device0.createBuffer({size: 2281, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let texture169 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba8sint'], |
| }); |
| let textureView161 = texture26.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 11, arrayLayerCount: 1}); |
| try { |
| computePassEncoder138.setBindGroup(1, bindGroup69, new Uint32Array(1977), 103, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| let textureView162 = texture112.createView({}); |
| try { |
| renderPassEncoder13.executeBundles([renderBundle8, renderBundle7]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 1, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 27, y: 21, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline39 = device0.createRenderPipeline({ |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule3, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'greater', |
| stencilReadMask: 286352031, |
| stencilWriteMask: 220467825, |
| depthBias: -1945576027, |
| depthBiasSlopeScale: 235.25284947047908, |
| depthBiasClamp: 174.28991846810004, |
| }, |
| vertex: {module: shaderModule0, constants: {}, buffers: []}, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'}, |
| }); |
| await gc(); |
| let buffer121 = device0.createBuffer({size: 9539, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let textureView163 = texture151.createView({}); |
| try { |
| renderPassEncoder27.executeBundles([renderBundle15, renderBundle21, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder37.setViewport(37.32129535023813, 3.4736149926413518, 49.873288383429916, 15.705526923735702, 0.04380060373099992, 0.3777101237683578); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline19); |
| } catch {} |
| let img3 = await imageWithData(28, 29, '#10101010', '#20202020'); |
| let autogeneratedBindGroupLayout73 = pipeline18.getBindGroupLayout(0); |
| let buffer122 = device0.createBuffer({size: 8140, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder164 = device0.createCommandEncoder({label: '\u4c41\u8df8\u45fb'}); |
| try { |
| computePassEncoder63.setBindGroup(2, bindGroup100, new Uint32Array(4324), 1_362, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setStencilReference(4096); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer98, 'uint16', 490, 377); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder164.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 612 */ |
| offset: 612, |
| buffer: buffer121, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData14, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 25, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture170 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView164 = texture64.createView({}); |
| let renderPassEncoder47 = commandEncoder164.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -881.4, g: 163.9, b: 418.7, a: -687.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 447581061, |
| }); |
| let sampler124 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 51.55, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder82.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle19]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(5, buffer62, 112); |
| } catch {} |
| try { |
| buffer94.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 384, new Int16Array(413), 16, 140); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 213, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 346, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup108 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 8, resource: {buffer: buffer50, offset: 0, size: 248}}], |
| }); |
| let commandEncoder165 = device0.createCommandEncoder(); |
| let textureView165 = texture74.createView({mipLevelCount: 1}); |
| let computePassEncoder140 = commandEncoder165.beginComputePass({}); |
| try { |
| computePassEncoder90.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| computePassEncoder140.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(94.4739255398464, 14.397441332520021, 1.5592759820390318, 20.842745047958864, 0.21238956095003125, 0.6165040542012713); |
| } catch {} |
| try { |
| await promise19; |
| } catch {} |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let texture171 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView166 = texture122.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup19, new Uint32Array(3471), 1_495, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup57, new Uint32Array(916), 131, 0); |
| } catch {} |
| try { |
| commandEncoder166.copyBufferToTexture({ |
| /* bytesInLastRow: 84 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1044 */ |
| offset: 1044, |
| bytesPerRow: 25088, |
| buffer: buffer84, |
| }, { |
| texture: texture90, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 1, y: 10 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 263, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledAutogeneratedBindGroupLayout2 = pipeline35.getBindGroupLayout(0); |
| let bindGroup109 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout47, |
| entries: [{binding: 8, resource: {buffer: buffer30, offset: 1792, size: 564}}], |
| }); |
| let textureView167 = texture148.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1}); |
| let computePassEncoder141 = commandEncoder166.beginComputePass({}); |
| let sampler125 = device0.createSampler({addressModeV: 'repeat', compare: 'less'}); |
| try { |
| computePassEncoder93.setBindGroup(2, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder141.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup92, new Uint32Array(1023), 151, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle18]); |
| } catch {} |
| try { |
| renderPassEncoder15.setStencilReference(841); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let texture172 = device0.createTexture({size: [240, 80, 1], format: 'depth32float', usage: GPUTextureUsage.RENDER_ATTACHMENT, viewFormats: []}); |
| let sampler126 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 87.21, |
| lodMaxClamp: 97.28, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(340); |
| } catch {} |
| let autogeneratedBindGroupLayout74 = pipeline4.getBindGroupLayout(0); |
| let texture173 = device0.createTexture({ |
| size: [120, 40, 20], |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler127 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 78.01, compare: 'never'}); |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(3, buffer43); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.append(canvas2); |
| let bindGroup110 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout28, |
| entries: [{binding: 8, resource: {buffer: buffer70, offset: 0}}], |
| }); |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let computePassEncoder142 = commandEncoder167.beginComputePass(); |
| try { |
| computePassEncoder83.setBindGroup(1, bindGroup10, new Uint32Array(615), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline10); |
| } catch {} |
| try { |
| computePassEncoder142.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer29, 'uint16', 1_198, 334); |
| } catch {} |
| let commandEncoder168 = device0.createCommandEncoder(); |
| let computePassEncoder143 = commandEncoder168.beginComputePass({}); |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup105, []); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer28, 'uint32', 1_124, 1_150); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer83, 0, 1_557); |
| } catch {} |
| try { |
| buffer104.unmap(); |
| } catch {} |
| document.body.prepend(img2); |
| let videoFrame24 = videoFrame4.clone(); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let recycledExplicitBindGroupLayout6 = pipeline28.getBindGroupLayout(0); |
| let buffer123 = device0.createBuffer({ |
| size: 3928, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder169 = device0.createCommandEncoder(); |
| let texture174 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture175 = gpuCanvasContext4.getCurrentTexture(); |
| let textureView168 = texture6.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1}); |
| let computePassEncoder144 = commandEncoder169.beginComputePass({}); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup8, new Uint32Array(2039), 107, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup83, new Uint32Array(1462), 373, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer124 = device0.createBuffer({size: 17335, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder97.setBindGroup(0, bindGroup99); |
| } catch {} |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup37, new Uint32Array(1148), 74, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer68, 40); }; |
| } catch {} |
| try { |
| computePassEncoder143.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer112, 'uint32', 356, 157); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer90, 0); |
| } catch {} |
| let bindGroup111 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 303, resource: textureView147}, |
| {binding: 261, resource: externalTexture1}, |
| {binding: 39, resource: textureView60}, |
| ], |
| }); |
| try { |
| computePassEncoder144.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(1, bindGroup22, new Uint32Array(936), 374, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer62, 'uint16', 1_502, 1_148); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout75 = pipeline27.getBindGroupLayout(0); |
| let bindGroup112 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout41, |
| entries: [{binding: 8, resource: {buffer: buffer8, offset: 0, size: 1708}}], |
| }); |
| let commandEncoder170 = device0.createCommandEncoder(); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder31.setBindGroup(3, bindGroup22, new Uint32Array(2443), 81, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer8, 'uint32', 64, 949); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(7, buffer17, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer53.unmap(); |
| } catch {} |
| try { |
| commandEncoder170.copyBufferToTexture({ |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2436 */ |
| offset: 2436, |
| bytesPerRow: 4096, |
| buffer: buffer74, |
| }, { |
| texture: texture118, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder170.copyTextureToTexture({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 30, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture176 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture177 = device0.createTexture({ |
| label: '\uf419\uce04\ueccf\u11d2\u398b\u8012\u{1fa94}\u0773\u0f15\u{1fe5f}\u{1fae3}', |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView169 = texture39.createView({dimension: '2d', baseArrayLayer: 8}); |
| let computePassEncoder145 = commandEncoder170.beginComputePass({}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup85); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder40.setVertexBuffer(2, buffer102, 3_972); |
| } catch {} |
| let pipeline40 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule4, entryPoint: 'compute5', constants: {}}}); |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let imageData32 = new ImageData(108, 20); |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 189, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView170 = texture176.createView({dimension: '3d', aspect: 'all', arrayLayerCount: 1}); |
| let texture178 = device0.createTexture({ |
| size: [60, 20, 15], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle22 = renderBundleEncoder22.finish({}); |
| try { |
| renderPassEncoder18.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder45.setIndexBuffer(buffer9, 'uint16', 980, 506); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer87.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture132, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(33).fill(52), /* required buffer size: 33 */ |
| {offset: 33, bytesPerRow: 9, rowsPerImage: 22}, {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup113 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout64, |
| entries: [{binding: 8, resource: {buffer: buffer7, offset: 4096, size: 180}}], |
| }); |
| let textureView171 = texture176.createView({}); |
| let sampler128 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'nearest', compare: 'equal', maxAnisotropy: 1}); |
| try { |
| computePassEncoder145.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup105, new Uint32Array(441), 90, 0); |
| } catch {} |
| let pipeline41 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule1, constants: {}}}); |
| try { |
| renderPassEncoder30.setViewport(39.16547340469037, 28.647565591013485, 27.34931982734788, 1.2782747314514176, 0.08411214380551635, 0.8515478640599239); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(0, buffer8, 0, 502); |
| } catch {} |
| let buffer125 = device0.createBuffer({ |
| size: 11901, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder171 = device0.createCommandEncoder({}); |
| let texture179 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 294}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView172 = texture132.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToBuffer(buffer23, 168, buffer68, 372, 36); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData27, |
| origin: { x: 0, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 86, y: 24, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 13, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let texture180 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder146 = commandEncoder171.beginComputePass(); |
| let sampler129 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.48, |
| maxAnisotropy: 10, |
| }); |
| let externalTexture24 = device0.importExternalTexture({source: videoFrame24}); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle18, renderBundle5, renderBundle13, renderBundle7, renderBundle7, renderBundle8, renderBundle20]); |
| } catch {} |
| try { |
| renderPassEncoder37.setBlendConstant({ r: 946.3, g: -449.8, b: 879.6, a: 891.7, }); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline34); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(0, buffer30, 1_892, 755); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer126 = device0.createBuffer({size: 5810, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder173 = device0.createCommandEncoder({}); |
| let textureView173 = texture180.createView({arrayLayerCount: 1}); |
| let renderPassEncoder48 = commandEncoder173.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -907.3, g: -210.1, b: -144.8, a: 212.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder146.setPipeline(pipeline25); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToTexture({ |
| /* bytesInLastRow: 76 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1116 */ |
| offset: 1116, |
| bytesPerRow: 25344, |
| rowsPerImage: 1247, |
| buffer: buffer118, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 5, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 19, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 108, new Int16Array(5834), 293, 28); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData15, |
| origin: { x: 9, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 90, y: 16, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 25, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline42 = await promise18; |
| document.body.prepend(canvas1); |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| let textureView174 = texture179.createView({}); |
| try { |
| computePassEncoder80.setBindGroup(0, bindGroup11, new Uint32Array(1195), 37, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer42, 1_712); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup9, new Uint32Array(2784), 122, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer72, 'uint16', 3_128, 69); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(3, buffer29); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData29, |
| origin: { x: 1, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 280, y: 64, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let texture181 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView175 = texture99.createView({dimension: '2d-array'}); |
| let computePassEncoder147 = commandEncoder174.beginComputePass({label: '\u02ca\udff5\u6c76'}); |
| let renderPassEncoder49 = commandEncoder26.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView13, |
| clearValue: { r: 980.2, g: 945.6, b: 404.6, a: -802.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView20, |
| depthClearValue: 0.4518504834394399, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilClearValue: 61337, |
| }, |
| occlusionQuerySet: querySet6, |
| maxDrawCount: 115152478, |
| }); |
| try { |
| computePassEncoder123.setBindGroup(1, bindGroup112); |
| } catch {} |
| try { |
| computePassEncoder147.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(3, bindGroup12, new Uint32Array(320), 33, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer69, 'uint32', 24, 319); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline27); |
| } catch {} |
| try { |
| commandEncoder172.clearBuffer(buffer116); |
| } catch {} |
| document.body.append(canvas1); |
| let autogeneratedBindGroupLayout76 = pipeline13.getBindGroupLayout(0); |
| let bindGroup114 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 8, resource: {buffer: buffer43, offset: 512, size: 348}}], |
| }); |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let textureView176 = texture148.createView({dimension: '2d-array'}); |
| let textureView177 = texture8.createView({format: 'depth32float', baseArrayLayer: 1, arrayLayerCount: 2}); |
| let computePassEncoder148 = commandEncoder172.beginComputePass({}); |
| let renderPassEncoder50 = commandEncoder175.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: 388.2, g: 369.9, b: 271.7, a: 150.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler130 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.46, |
| compare: 'not-equal', |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder144.setBindGroup(3, bindGroup67); |
| } catch {} |
| try { |
| computePassEncoder40.setBindGroup(3, bindGroup33, new Uint32Array(374), 75, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder148.setPipeline(pipeline20); |
| } catch {} |
| let offscreenCanvas4 = new OffscreenCanvas(352, 218); |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'bt2020_10bit'} }); |
| let buffer127 = device0.createBuffer({size: 2646, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'}); |
| } catch {} |
| let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout57, autogeneratedBindGroupLayout17]}); |
| let texture182 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 25}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder18.setVertexBuffer(4, buffer83); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| let imageData33 = new ImageData(24, 56); |
| let buffer128 = device0.createBuffer({size: 6570, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| try { |
| computePassEncoder113.setBindGroup(0, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder34.executeBundles([renderBundle7]); |
| } catch {} |
| document.body.append(img2); |
| let commandEncoder176 = device0.createCommandEncoder(); |
| let textureView178 = texture135.createView({mipLevelCount: 1}); |
| let computePassEncoder149 = commandEncoder176.beginComputePass({}); |
| let sampler131 = device0.createSampler({label: '\u122a\u5378\u21ad\u9ccf\u051f\u00a8\ud1f2\u36df\u0eb9', addressModeV: 'repeat'}); |
| try { |
| computePassEncoder144.pushDebugGroup('\u0993'); |
| } catch {} |
| try { |
| renderPassEncoder32.insertDebugMarker('\u2ae9'); |
| } catch {} |
| let pipeline43 = device0.createRenderPipeline({ |
| layout: pipelineLayout10, |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rgba8sint', writeMask: 0}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilReadMask: 188841631, |
| stencilWriteMask: 427737036, |
| depthBiasSlopeScale: 682.6888620517204, |
| depthBiasClamp: 699.977410448268, |
| }, |
| vertex: {module: shaderModule0, buffers: []}, |
| }); |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder136.setBindGroup(1, bindGroup114); |
| } catch {} |
| try { |
| computePassEncoder149.setPipeline(pipeline40); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer114, 0); |
| } catch {} |
| let arrayBuffer12 = buffer65.getMappedRange(112, 108); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let recycledExplicitBindGroupLayout7 = pipeline41.getBindGroupLayout(0); |
| let computePassEncoder150 = commandEncoder177.beginComputePass({}); |
| let sampler132 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.08, |
| compare: 'always', |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder67.setBindGroup(1, bindGroup78); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline16); |
| } catch {} |
| try { |
| computePassEncoder150.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(3, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline32); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let bindGroup115 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout18, |
| entries: [{binding: 8, resource: {buffer: buffer84, offset: 256, size: 856}}], |
| }); |
| try { |
| computePassEncoder137.setBindGroup(1, bindGroup98); |
| } catch {} |
| try { |
| computePassEncoder133.setBindGroup(0, bindGroup35, new Uint32Array(1975), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle6, renderBundle16]); |
| } catch {} |
| let recycledExplicitBindGroupLayout8 = pipeline5.getBindGroupLayout(1); |
| let commandEncoder178 = device0.createCommandEncoder({}); |
| let texture183 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder34.setVertexBuffer(5, buffer33, 444, 48); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 8, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 71, y: 41, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas5 = new OffscreenCanvas(198, 76); |
| let computePassEncoder151 = commandEncoder178.beginComputePass(); |
| try { |
| computePassEncoder151.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer36, 'uint16', 472, 139); |
| } catch {} |
| let recycledExplicitBindGroupLayout9 = pipeline39.getBindGroupLayout(0); |
| let commandEncoder179 = device0.createCommandEncoder(); |
| let renderPassEncoder51 = commandEncoder179.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -379.1, g: -676.7, b: -658.9, a: 302.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder93.setBindGroup(1, bindGroup10, new Uint32Array(231), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup41, new Uint32Array(3266), 154, 0); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 68, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder180 = device0.createCommandEncoder(); |
| let texture184 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder99.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer62, 272, 1_360); |
| } catch {} |
| try { |
| commandEncoder3.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2640 */ |
| offset: 2640, |
| bytesPerRow: 20480, |
| buffer: buffer33, |
| }, { |
| texture: texture102, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup116 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout14, |
| entries: [{binding: 8, resource: {buffer: buffer108, offset: 0, size: 800}}], |
| }); |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| let textureView179 = texture179.createView({}); |
| let renderPassEncoder52 = commandEncoder180.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView81, |
| clearValue: { r: 811.8, g: 924.8, b: 916.6, a: 287.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView44, |
| depthClearValue: 0.8600335979097944, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'store', |
| depthReadOnly: false, |
| stencilClearValue: 5074, |
| }, |
| occlusionQuerySet: querySet7, |
| }); |
| try { |
| computePassEncoder129.setBindGroup(1, bindGroup78, new Uint32Array(1851), 1_439, 0); |
| } catch {} |
| try { |
| commandEncoder3.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 968 */ |
| offset: 968, |
| bytesPerRow: 44800, |
| buffer: buffer89, |
| }, { |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 3}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture136, |
| mipLevel: 0, |
| origin: {x: 3, y: 1, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(122).fill(22), /* required buffer size: 122 */ |
| {offset: 59, bytesPerRow: 43}, {width: 5, height: 2, depthOrArrayLayers: 1}); |
| } catch {} |
| let recycledExplicitBindGroupLayout10 = pipeline43.getBindGroupLayout(0); |
| let computePassEncoder152 = commandEncoder181.beginComputePass({}); |
| let renderPassEncoder53 = commandEncoder3.beginRenderPass({ |
| colorAttachments: [{view: textureView73, depthSlice: 20, loadOp: 'clear', storeOp: 'discard'}], |
| depthStencilAttachment: {view: textureView44, depthLoadOp: 'load', depthStoreOp: 'store', depthReadOnly: false}, |
| }); |
| try { |
| computePassEncoder152.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup95); |
| } catch {} |
| try { |
| renderPassEncoder42.executeBundles([renderBundle1, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, undefined, 0, 243_208_212); |
| } catch {} |
| try { |
| computePassEncoder144.popDebugGroup(); |
| } catch {} |
| let bindGroup117 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [{binding: 32, resource: {buffer: buffer123, offset: 0}}], |
| }); |
| try { |
| computePassEncoder121.setBindGroup(1, bindGroup76); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(4, buffer17); |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'hlg'} }); |
| try { |
| bindGroup38.label = '\u6813\u6046\u0d6b\u{1ffe4}\u6918\uffc0\u{1fa27}\ua955\u39a4\u{1f68c}'; |
| } catch {} |
| let commandEncoder182 = device0.createCommandEncoder({}); |
| let querySet25 = device0.createQuerySet({type: 'occlusion', count: 0}); |
| let texture185 = device0.createTexture({ |
| size: [2, 2, 66], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder153 = commandEncoder182.beginComputePass({}); |
| try { |
| computePassEncoder153.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await buffer111.mapAsync(GPUMapMode.WRITE, 184, 4764); |
| } catch {} |
| try { |
| computePassEncoder42.insertDebugMarker('\u00e4'); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 35, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 58, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 96, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 205, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 285, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 309, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 334, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d' }, |
| }, |
| {binding: 376, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let autogeneratedBindGroupLayout77 = pipeline32.getBindGroupLayout(0); |
| let textureView180 = texture136.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 0, baseArrayLayer: 3, arrayLayerCount: 1}); |
| document.body.append(canvas1); |
| let bindGroup118 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout54, |
| entries: [{binding: 8, resource: {buffer: buffer97, offset: 256, size: 668}}], |
| }); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let computePassEncoder154 = commandEncoder183.beginComputePass(); |
| try { |
| computePassEncoder125.setBindGroup(2, bindGroup115); |
| } catch {} |
| try { |
| computePassEncoder127.setBindGroup(1, bindGroup33, new Uint32Array(937), 140, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer89, 'uint16', 84, 183); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(1, buffer34, 12, 1_286); |
| } catch {} |
| let commandEncoder184 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder154.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder184.copyTextureToBuffer({ |
| texture: texture99, |
| mipLevel: 0, |
| origin: {x: 22, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1780 */ |
| offset: 1780, |
| bytesPerRow: 9216, |
| buffer: buffer116, |
| }, {width: 1, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer40, 20364, new Int16Array(10770), 5889, 8); |
| } catch {} |
| let pipeline44 = await promise17; |
| let autogeneratedBindGroupLayout78 = pipeline42.getBindGroupLayout(0); |
| let bindGroup119 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [{binding: 396, resource: {buffer: buffer115, offset: 1024, size: 864}}], |
| }); |
| let buffer129 = device0.createBuffer({ |
| size: 15508, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture186 = device0.createTexture({ |
| size: [2, 2, 11], |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder155 = commandEncoder184.beginComputePass({}); |
| let externalTexture25 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder25.setScissorRect(24, 4, 1, 16); |
| } catch {} |
| try { |
| computePassEncoder95.insertDebugMarker('\uf67d'); |
| } catch {} |
| let autogeneratedBindGroupLayout79 = pipeline13.getBindGroupLayout(0); |
| let commandEncoder185 = device0.createCommandEncoder({}); |
| let textureView181 = texture180.createView({dimension: '1d'}); |
| let texture187 = device0.createTexture({ |
| size: [60, 20, 44], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder156 = commandEncoder185.beginComputePass({}); |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer78, 'uint32', 1_072, 34); |
| } catch {} |
| let imageBitmap6 = await createImageBitmap(videoFrame3); |
| let recycledExplicitBindGroupLayout11 = pipeline28.getBindGroupLayout(0); |
| let sampler133 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 65.72, |
| }); |
| try { |
| computePassEncoder127.setBindGroup(0, bindGroup40, new Uint32Array(1116), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setPipeline(pipeline24); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder127); computePassEncoder127.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline9); |
| } catch {} |
| document.body.append(img1); |
| let buffer130 = device0.createBuffer({size: 2418, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let sampler134 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMinClamp: 19.48, |
| }); |
| try { |
| computePassEncoder156.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer123, 'uint16', 844, 138); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture164, |
| mipLevel: 0, |
| origin: {x: 5, y: 9, z: 6}, |
| aspect: 'all', |
| }, new Uint8Array(58_637).fill(11), /* required buffer size: 58_637 */ |
| {offset: 269, bytesPerRow: 96, rowsPerImage: 152}, {width: 11, height: 0, depthOrArrayLayers: 5}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData32, |
| origin: { x: 27, y: 7 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 323, y: 99, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 12, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'unspecified'} }); |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' }, |
| }, |
| {binding: 20, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }}, |
| { |
| binding: 40, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 46, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 61, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 70, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 79, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 89, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 97, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 112, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 158, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 175, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 181, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }}, |
| { |
| binding: 258, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 317, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 427, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder71.setBindGroup(1, bindGroup113, new Uint32Array(142), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder155.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer86, 'uint16', 1_304, 790); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline43); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| let texture188 = device0.createTexture({ |
| size: {width: 2}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder49.executeBundles([renderBundle7, renderBundle16, renderBundle0, renderBundle11, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(5, buffer78, 96, 231); |
| } catch {} |
| let bindGroup120 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [{binding: 8, resource: {buffer: buffer43, offset: 512, size: 228}}], |
| }); |
| let textureView182 = texture181.createView({format: 'rgba8sint'}); |
| let sampler135 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| compare: 'less-equal', |
| }); |
| try { |
| computePassEncoder106.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap4, |
| origin: { x: 7, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 260, y: 21, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 16, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| let computePassEncoder157 = commandEncoder186.beginComputePass({}); |
| let sampler136 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| computePassEncoder157.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline44); |
| } catch {} |
| let autogeneratedBindGroupLayout80 = pipeline2.getBindGroupLayout(0); |
| let bindGroup121 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout8, |
| entries: [{binding: 396, resource: {buffer: buffer28, offset: 0}}], |
| }); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder90.setBindGroup(3, bindGroup48, new Uint32Array(865), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder40.setIndexBuffer(buffer112, 'uint32', 600, 10); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(2, bindGroup24); |
| } catch {} |
| let buffer131 = device0.createBuffer({size: 3303, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let renderPassEncoder54 = commandEncoder187.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView40, |
| depthSlice: 20, |
| clearValue: { r: 390.1, g: -547.4, b: 380.7, a: -620.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView169, |
| depthClearValue: 0.9317817342425659, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| stencilReadOnly: true, |
| }, |
| }); |
| let sampler137 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 72.96, |
| maxAnisotropy: 6, |
| }); |
| try { |
| renderPassEncoder42.setBindGroup(0, bindGroup41, new Uint32Array(1224), 13, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(0, bindGroup107); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(0, bindGroup36, new Uint32Array(705), 41, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(4, buffer86, 0, 9_239); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 68, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let bindGroup122 = device0.createBindGroup({ |
| label: '\ub32a\u4395\uaf11\ude42\u8e60\u0abc\u8de4\uf985', |
| layout: autogeneratedBindGroupLayout29, |
| entries: [{binding: 8, resource: {buffer: buffer84, offset: 1280, size: 316}}], |
| }); |
| let commandEncoder188 = device0.createCommandEncoder(); |
| let texture189 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 35}, |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView183 = texture34.createView({arrayLayerCount: 1}); |
| let renderPassEncoder55 = commandEncoder188.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 12, |
| clearValue: { r: -613.2, g: 833.5, b: 328.5, a: 442.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView121, |
| depthClearValue: 0.7589916562470291, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| stencilClearValue: 42535, |
| }, |
| }); |
| let renderBundle23 = renderBundleEncoder23.finish({}); |
| let sampler138 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.73, |
| compare: 'not-equal', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder127); computePassEncoder127.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 13, y: 15, z: 63}, |
| aspect: 'all', |
| }, new Uint8Array(4_159).fill(237), /* required buffer size: 4_159 */ |
| {offset: 55, bytesPerRow: 228, rowsPerImage: 3}, {width: 49, height: 0, depthOrArrayLayers: 7}); |
| } catch {} |
| let gpuCanvasContext6 = offscreenCanvas4.getContext('webgpu'); |
| let buffer132 = device0.createBuffer({ |
| size: 8919, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder189 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder39.setBindGroup(3, bindGroup35, new Uint32Array(850), 55, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline26); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture190 = device0.createTexture({size: {width: 30}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder158 = commandEncoder189.beginComputePass({}); |
| try { |
| computePassEncoder158.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder50.executeBundles([renderBundle14]); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline39); |
| } catch {} |
| try { |
| buffer44.unmap(); |
| } catch {} |
| let bindGroup123 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout19, |
| entries: [{binding: 8, resource: {buffer: buffer118, offset: 19456, size: 7752}}], |
| }); |
| let textureView184 = texture41.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 2, baseArrayLayer: 16}); |
| try { |
| renderPassEncoder44.executeBundles([renderBundle10, renderBundle14, renderBundle19, renderBundle14, renderBundle14]); |
| } catch {} |
| try { |
| computePassEncoder127.insertDebugMarker('\u9328'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 16, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer133 = device0.createBuffer({size: 12491, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder190 = device0.createCommandEncoder({}); |
| let textureView185 = texture82.createView({format: 'rg32uint', mipLevelCount: 1}); |
| try { |
| computePassEncoder65.setBindGroup(3, bindGroup67, []); |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder42.executeBundles([renderBundle7, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(1, buffer73, 88); |
| } catch {} |
| try { |
| commandEncoder190.resolveQuerySet(querySet1, 187, 22, buffer70, 1536); |
| } catch {} |
| let pipeline45 = await device0.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule1}}); |
| let textureView186 = texture27.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder95.setBindGroup(0, bindGroup58, new Uint32Array(619), 224, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup62); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup25, new Uint32Array(2218), 314, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer118, 0); |
| } catch {} |
| try { |
| commandEncoder190.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2336 */ |
| offset: 2336, |
| buffer: buffer85, |
| }, { |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder190.insertDebugMarker('\u{1fd7d}'); |
| } catch {} |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let texture191 = device0.createTexture({ |
| size: [240, 80, 14], |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView187 = texture86.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| let computePassEncoder159 = commandEncoder191.beginComputePass({}); |
| try { |
| computePassEncoder126.setBindGroup(3, bindGroup112, new Uint32Array(1807), 642, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup105); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup74, new Uint32Array(1237), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(27); |
| } catch {} |
| try { |
| renderPassEncoder9.setScissorRect(4, 0, 5, 2); |
| } catch {} |
| try { |
| renderPassEncoder49.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(0, buffer120, 668, 309); |
| } catch {} |
| try { |
| computePassEncoder48.pushDebugGroup('\udbba'); |
| } catch {} |
| let pipeline46 = await device0.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule0, constants: {}}}); |
| try { |
| globalThis.someLabel = externalTexture18.label; |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let texture192 = gpuCanvasContext4.getCurrentTexture(); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle24 = renderBundleEncoder24.finish({}); |
| let externalTexture26 = device0.importExternalTexture({source: videoFrame19}); |
| try { |
| computePassEncoder76.setBindGroup(1, bindGroup91, []); |
| } catch {} |
| try { |
| computePassEncoder127.end(); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(6, buffer40, 11_416, 2_221); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| try { |
| adapter0.label = '\u044f\u9d7e\u834a\u194b\u{1fa87}'; |
| } catch {} |
| let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout65]}); |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| let computePassEncoder160 = commandEncoder190.beginComputePass(); |
| let renderPassEncoder56 = commandEncoder193.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView120, |
| clearValue: { r: -43.12, g: 596.2, b: 516.4, a: 894.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet19, |
| maxDrawCount: 316559435, |
| }); |
| let externalTexture27 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder79.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(2, bindGroup85); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup124 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 53, resource: {buffer: buffer5, offset: 512}}], |
| }); |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let textureView188 = texture165.createView({}); |
| let texture193 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder161 = commandEncoder42.beginComputePass({}); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1}); |
| try { |
| computePassEncoder133.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(2, buffer98); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder192.resolveQuerySet(querySet19, 7, 57, buffer99, 256); |
| } catch {} |
| let bindGroup125 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer107, offset: 256, size: 48}}], |
| }); |
| let computePassEncoder162 = commandEncoder194.beginComputePass(); |
| let renderBundle25 = renderBundleEncoder25.finish({}); |
| let sampler139 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 88.67, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder82.setBindGroup(1, bindGroup55); |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline5); |
| } catch {} |
| try { |
| computePassEncoder159.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(4, buffer33); |
| } catch {} |
| try { |
| commandEncoder192.copyBufferToBuffer(buffer113, 10296, buffer105, 500, 72); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let imageBitmap7 = await createImageBitmap(videoFrame1); |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'bt2020_10bit'} }); |
| let buffer134 = device0.createBuffer({ |
| size: 7456, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder195 = device0.createCommandEncoder({}); |
| let externalTexture28 = device0.importExternalTexture({source: videoFrame22, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder44.setBindGroup(3, bindGroup24); |
| } catch {} |
| let buffer135 = device0.createBuffer({size: 20111, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder160.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer101, 'uint32', 6_804, 353); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, buffer97, 436); |
| } catch {} |
| try { |
| commandEncoder195.insertDebugMarker('\u2312'); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer50, 36, new BigUint64Array(4025), 1034, 12); |
| } catch {} |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 11, y: 11 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 190, y: 34, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise22; |
| } catch {} |
| document.body.append(canvas0); |
| let veryExplicitBindGroupLayout29 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 72, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 198, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer136 = device0.createBuffer({size: 8792, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture194 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder137.setBindGroup(1, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder162.setPipeline(pipeline45); |
| } catch {} |
| try { |
| renderPassEncoder15.pushDebugGroup('\u3af7'); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout81 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder196 = device0.createCommandEncoder(); |
| let texture195 = device0.createTexture({ |
| size: [120, 40, 147], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture196 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 16}, |
| mipLevelCount: 2, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView189 = texture131.createView({}); |
| let sampler140 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 67.80, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder161.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup108, new Uint32Array(2170), 362, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer22, 'uint32', 5_388, 14_077); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(7, buffer69); |
| } catch {} |
| try { |
| commandEncoder195.insertDebugMarker('\ubfcb'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'bt2020_10bit'} }); |
| let bindGroup126 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout15, |
| entries: [{binding: 8, resource: {buffer: buffer129, offset: 0}}], |
| }); |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let texture197 = device0.createTexture({ |
| label: '\u{1fbb8}\u0681', |
| size: {width: 240}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView190 = texture99.createView({dimension: '2d-array'}); |
| let computePassEncoder163 = commandEncoder196.beginComputePass(); |
| let renderPassEncoder57 = commandEncoder197.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -765.4, g: -192.2, b: -590.1, a: -176.2, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| try { |
| renderPassEncoder55.executeBundles([renderBundle6, renderBundle18]); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(6, buffer26, 2_812, 1_547); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup10, []); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer46, 'uint16', 166, 558); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline32); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext7 = offscreenCanvas5.getContext('webgpu'); |
| let bindGroup127 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout47, |
| entries: [{binding: 8, resource: {buffer: buffer82, offset: 768, size: 592}}], |
| }); |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let renderPassEncoder58 = commandEncoder198.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 34, |
| clearValue: { r: -608.0, g: -795.4, b: -766.6, a: 639.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView61, depthReadOnly: true, stencilReadOnly: false}, |
| }); |
| let externalTexture29 = device0.importExternalTexture({source: videoFrame25}); |
| try { |
| computePassEncoder163.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder38.setViewport(21.022865637131584, 4.57122140807158, 0.5022060770878405, 1.1294527532597167, 0.836565883192145, 0.9204101010929906); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer87, 'uint16', 56, 22); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup75); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer64, 'uint32', 0, 630); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline34); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture197, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(19).fill(31), /* required buffer size: 19 */ |
| {offset: 19, rowsPerImage: 43}, {width: 50, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 4, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 192, y: 20, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup128 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout14, |
| entries: [{binding: 8, resource: {buffer: buffer119, offset: 3584}}], |
| }); |
| let commandEncoder199 = device0.createCommandEncoder(); |
| let texture198 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture199 = gpuCanvasContext3.getCurrentTexture(); |
| let computePassEncoder164 = commandEncoder199.beginComputePass(); |
| let renderPassEncoder59 = commandEncoder192.beginRenderPass({ |
| colorAttachments: [{view: textureView120, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 119672471, |
| }); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder160.setBindGroup(1, bindGroup49, new Uint32Array(1456), 475, 0); |
| } catch {} |
| try { |
| computePassEncoder164.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(3, bindGroup35, new Uint32Array(3559), 557, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(4, buffer121, 4, 2_506); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer112, 'uint16', 12, 167); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let imageData34 = new ImageData(12, 48); |
| let computePassEncoder165 = commandEncoder195.beginComputePass({}); |
| try { |
| computePassEncoder134.setBindGroup(1, bindGroup86); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(2, buffer38, 56, 2_458); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer109, 'uint16', 14, 12); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(0, buffer78, 0, 128); |
| } catch {} |
| try { |
| adapter0.label = '\udfd3\u0d6a\u0252\u04cc\u89c0\u04c6\u00f7\u0e77'; |
| } catch {} |
| let buffer137 = device0.createBuffer({ |
| label: '\u937b\u9e6b\u{1fc5d}\u{1ffa4}', |
| size: 23589, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView191 = texture129.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6}); |
| let texture200 = device0.createTexture({ |
| label: '\u5112\u9e02\u3284\u0627\u{1feb9}\u0ae0\u0468\u0132\u5ae0', |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView192 = texture168.createView({dimension: 'cube', baseArrayLayer: 0}); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup39, []); |
| } catch {} |
| try { |
| computePassEncoder165.setPipeline(pipeline42); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup121, new Uint32Array(2817), 98, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(5, undefined, 0, 714_000_563); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup89, new Uint32Array(2112), 3, 0); |
| } catch {} |
| let textureView193 = texture9.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 13}); |
| try { |
| renderPassEncoder16.setBlendConstant({ r: 628.2, g: -827.1, b: -848.7, a: 427.5, }); |
| } catch {} |
| try { |
| renderPassEncoder56.setIndexBuffer(buffer114, 'uint32', 0, 13); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(7, buffer120); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer109, 8, new BigUint64Array(4505), 540, 0); |
| } catch {} |
| let offscreenCanvas6 = new OffscreenCanvas(222, 74); |
| let buffer138 = device0.createBuffer({size: 1131, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder200 = device0.createCommandEncoder({}); |
| let querySet26 = device0.createQuerySet({type: 'occlusion', count: 11}); |
| let computePassEncoder166 = commandEncoder200.beginComputePass({}); |
| let sampler141 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 77.17, |
| lodMaxClamp: 86.97, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder166.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder45.setBindGroup(1, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(7, buffer82); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(1, bindGroup46); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline43); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(108).fill(253), /* required buffer size: 108 */ |
| {offset: 108, bytesPerRow: 268}, {width: 57, height: 39, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder201 = device0.createCommandEncoder({}); |
| let computePassEncoder167 = commandEncoder201.beginComputePass({}); |
| try { |
| computePassEncoder136.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder50.setVertexBuffer(2, buffer97, 700, 85); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(4, buffer19, 0, 1_317); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer105, 408, new Float32Array(1006), 9, 56); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| let bindGroup129 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout58, |
| entries: [{binding: 8, resource: {buffer: buffer125, offset: 0, size: 400}}], |
| }); |
| let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout21]}); |
| let texture201 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 18}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(3, bindGroup62, new Uint32Array(2419), 367, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer101, 'uint16', 2_392, 908); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(3, bindGroup48, []); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer62, 'uint32', 1_216, 1_569); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(4, buffer39, 0, 2_376); |
| } catch {} |
| let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt709', transfer: 'gamma28curve'} }); |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| struct FragmentOutput5 { |
| @location(0) @interpolate(flat, sample) f0: vec4i, |
| @builtin(sample_mask) f1: u32, |
| @builtin(frag_depth) f2: f32, |
| } |
| |
| @group(0) @binding(203) var<storage, read> buffer139: vec2f; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| @size(8) f0: array<i32>, |
| } |
| |
| var<workgroup> vw25: array<f32, 41>; |
| |
| struct VertexOutput3 { |
| @builtin(position) f7: vec4f, |
| } |
| |
| fn fn0(a0: ptr<storage, array<vec2u, 1>, read>) -> array<mat3x3h, 1> { |
| var out: array<mat3x3h, 1>; |
| out[u32(unconst_u32(79))] = mat3x3h(f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))]), f16((*a0)[u32(unconst_u32(222))][u32(unconst_u32(164))])); |
| out[0] = mat3x3h(f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1)), f16(textureNumLayers(tex1))); |
| out[u32(unconst_u32(45))] = mat3x3h(vec3h(unpack4x8unorm(u32(unconst_u32(127))).xyy), vec3h(unpack4x8unorm(u32(unconst_u32(127))).yzx), vec3h(unpack4x8unorm(u32(unconst_u32(127))).wyx)); |
| var vf32: u32 = textureNumLayers(tex1); |
| vf32 = pack4x8unorm(unpack4x8unorm(u32(unconst_u32(131)))); |
| vf32 -= textureDimensions(tex1).x; |
| let vf33: i32 = dot4I8Packed(u32(unconst_u32(104)), u32(unconst_u32(55))); |
| var vf34: u32 = textureNumLevels(tex1); |
| vf34 = (*a0)[0].y; |
| let ptr105: ptr<storage, vec2u, read> = &(*a0)[0]; |
| let vf35: vec4f = unpack4x8unorm(u32(unconst_u32(99))); |
| let vf36: vec2u = textureDimensions(tex1, i32(unconst_i32(64))); |
| let vf37: i32 = insertBits(i32(unconst_i32(88)), i32(unconst_i32(447)), u32(unconst_u32(4)), u32(unconst_u32(191))); |
| out[u32(unconst_u32(91))] = mat3x3h(f16(vf37), f16(vf37), f16(vf37), f16(vf37), f16(vf37), f16(vf37), f16(vf37), f16(vf37), f16(vf37)); |
| let vf38: u32 = pack4xU8(vec4u(unconst_u32(192), unconst_u32(219), unconst_u32(80), unconst_u32(184))); |
| var vf39: i32 = vf33; |
| vf32 <<= (*a0)[0][0]; |
| out[u32(unconst_u32(271))] = mat3x3h(f16(vf39), f16(vf39), f16(vf39), f16(vf39), f16(vf39), f16(vf39), f16(vf39), f16(vf39), f16(vf39)); |
| vf39 = i32(unpack4x8unorm(u32(unconst_u32(338))).w); |
| let ptr106: ptr<function, i32> = &vf39; |
| let ptr107: ptr<storage, vec2u, read> = &(*a0)[0]; |
| let vf40: vec4f = vf35; |
| let ptr108: ptr<storage, vec2u, read> = &(*a0)[0]; |
| var vf41: vec2h = clamp(vec2h(unconst_f16(7845.5), unconst_f16(1965.8)), vec2h(unconst_f16(-18307.8), unconst_f16(3099.0)), vec2h(unconst_f16(9669.1), unconst_f16(3374.2))); |
| return out; |
| _ = tex1; |
| } |
| |
| var<workgroup> vw26: array<mat4x4f, 3>; |
| |
| fn fn1(a0: array<array<S5, 10>, 1>, a1: ptr<workgroup, S4>) -> mat3x2f { |
| var out: mat3x2f; |
| let vf42: S5 = a0[u32(unconst_u32(232))][9]; |
| let vf43: vec3h = fma(vec3h(unconst_f16(27334.1), unconst_f16(1915.1), unconst_f16(12473.4)), vec3h(unconst_f16(-2522.3), unconst_f16(6706.1), unconst_f16(2332.1)), vec3h(unconst_f16(8981.8), unconst_f16(-7441.5), unconst_f16(1632.5))); |
| return out; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct S5 { |
| @builtin(workgroup_id) @size(16) f0: vec3u, |
| } |
| |
| fn fn2() -> mat2x2f { |
| var out: mat2x2f; |
| out = mat2x2f(inverseSqrt(vec3f(unconst_f32(0.5419), unconst_f32(0.3214), unconst_f32(0.06507))).yz, inverseSqrt(vec3f(unconst_f32(0.5419), unconst_f32(0.3214), unconst_f32(0.06507))).zy); |
| out = mat2x2f(degrees(vec4f(unconst_f32(0.1591), unconst_f32(0.2931), unconst_f32(0.09321), unconst_f32(0.1529))).gg, degrees(vec4f(unconst_f32(0.1591), unconst_f32(0.2931), unconst_f32(0.09321), unconst_f32(0.1529))).yy); |
| out += mat2x2f(vec2f(round(vec3h(unconst_f16(17247.9), unconst_f16(4457.1), unconst_f16(13062.5))).bb), vec2f(round(vec3h(unconst_f16(17247.9), unconst_f16(4457.1), unconst_f16(13062.5))).zy)); |
| var vf44: vec3f = floor(vec3f(unconst_f32(0.00587), unconst_f32(0.00536), unconst_f32(0.04498))); |
| out = mat2x2f(unpack4x8snorm(u32(unconst_u32(297))).ag, unpack4x8snorm(u32(unconst_u32(297))).xw); |
| var vf45: vec3h = round(vec3h(unconst_f16(1097.0), unconst_f16(1448.4), unconst_f16(3088.8))); |
| var vf46: u32 = textureNumLevels(tex1); |
| vf44 = vec3f(f32(length(f16(unconst_f16(6755.7))))); |
| vf44 = vec3f(bitcast<f32>(vf46)); |
| let vf47: vec4i = reverseBits(vec4i(unconst_i32(76), unconst_i32(75), unconst_i32(-88), unconst_i32(155))); |
| return out; |
| _ = tex1; |
| } |
| |
| var<workgroup> vw24: atomic<i32>; |
| |
| struct S4 { |
| @location(11) @interpolate(perspective) f0: f32, |
| @location(14) f1: vec2f, |
| @location(7) f2: vec2h, |
| @location(2) f3: vec4h, |
| } |
| |
| @group(1) @binding(216) var tex1: texture_cube_array<f32>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @vertex |
| fn vertex4(@location(0) @interpolate(flat, centroid) a0: vec4f, a1: S4, @location(13) @interpolate(linear, centroid) a2: f16) -> VertexOutput3 { |
| var out: VertexOutput3; |
| var vf48 = fn2(); |
| out.f7 += vec4f(f32(pow(f16(unconst_f16(3203.6)), f16(unconst_f16(34018.9))))); |
| var vf49 = fn2(); |
| vf49 += mat2x2f(f32(a1.f2[u32(unconst_u32(26))]), f32(a1.f2[u32(unconst_u32(26))]), f32(a1.f2[u32(unconst_u32(26))]), f32(a1.f2[u32(unconst_u32(26))])); |
| vf48 = mat2x2f(vec2f(a1.f2), vec2f(a1.f2)); |
| let vf50: u32 = pack2x16unorm(vec2f(unconst_f32(0.06854), unconst_f32(-0.2016))); |
| vf49 = mat2x2f(vec2f(a1.f2), vec2f(a1.f2)); |
| var vf51: f16 = pow(f16(unconst_f16(4209.0)), f16(unconst_f16(2047.8))); |
| var vf52: u32 = textureNumLevels(tex1); |
| let vf53: vec4f = tanh(vec4f(unconst_f32(-0.09074), unconst_f32(-0.1225), unconst_f32(0.01103), unconst_f32(0.2854))); |
| let vf54: vec2u = textureDimensions(tex1, i32(unconst_i32(170))); |
| fn2(); |
| var vf55 = fn2(); |
| out.f7 = vec4f(vf53[u32(unconst_u32(251))]); |
| vf49 = mat2x2f(a0.rr, a0.aa); |
| return out; |
| _ = tex1; |
| } |
| |
| @fragment |
| fn fragment5() -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| var vf56: vec4h = acosh(vec4h(unconst_f16(7456.9), unconst_f16(16119.3), unconst_f16(343.5), unconst_f16(1137.0))); |
| var vf57: vec3f = ceil(vec3f(unconst_f32(0.02999), unconst_f32(0.1359), unconst_f32(0.1997))); |
| vf56 = vec4h(clamp(vec3f(unconst_f32(-0.1938), unconst_f32(0.05100), unconst_f32(0.3201)), vec3f(unconst_f32(0.3146), unconst_f32(0.03836), unconst_f32(0.3839)), vec3f(unconst_f32(0.5429), unconst_f32(-0.06343), unconst_f32(0.08911))).ggrb); |
| var vf58: vec3f = exp2(vec3f(unconst_f32(-0.03142), unconst_f32(-0.4067), unconst_f32(0.3754))); |
| out.f0 &= countOneBits(vec4i(unconst_i32(304), unconst_i32(22), unconst_i32(219), unconst_i32(124))); |
| out.f2 = unpack2x16unorm(u32(unconst_u32(80))).r; |
| var vf59: vec2f = unpack2x16unorm(bitcast<vec3u>(insertBits(vec3i(unconst_i32(229), unconst_i32(383), unconst_i32(-19)), vec3i(unconst_i32(41), unconst_i32(-142), unconst_i32(245)), u32(unconst_u32(99)), u32(unconst_u32(138))))[0]); |
| out.f0 -= vec4i(i32(vf56[u32(unconst_u32(234))])); |
| let ptr109: ptr<function, vec3f> = &vf58; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute6(@builtin(num_workgroups) a0: vec3u, a1: S5) { |
| var vf60: f32 = ldexp(f32(unconst_f32(0.5491)), i32(unconst_i32(94))); |
| vw26[2] += mat4x4f(unpack2x16unorm(u32(unconst_u32(187))).yyxx, unpack2x16unorm(u32(unconst_u32(187))).rggr, unpack2x16unorm(u32(unconst_u32(187))).rrgr, unpack2x16unorm(u32(unconst_u32(187))).xyxx); |
| vw26[u32(unconst_u32(6))] = mat4x4f(vec4f(a1.f0.rrbr), bitcast<vec4f>(a1.f0.bbbb), bitcast<vec4f>(a1.f0.xxzy), bitcast<vec4f>(a1.f0.xzzy)); |
| atomicAnd(&vw24, i32(unconst_i32(584))); |
| let vf61: vec3f = cos(vec3f(unconst_f32(0.3356), unconst_f32(0.02115), unconst_f32(0.09524))); |
| let ptr110: ptr<storage, vec2f, read> = &buffer139; |
| _ = buffer139; |
| }`, |
| }); |
| let bindGroup130 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [{binding: 8, resource: {buffer: buffer82, offset: 0, size: 344}}], |
| }); |
| let textureView194 = texture194.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| let renderBundle26 = renderBundleEncoder26.finish({}); |
| try { |
| renderPassEncoder45.setBindGroup(0, bindGroup39, []); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(1, buffer15, 23_616, 507); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let texture202 = device0.createTexture({ |
| size: [30, 10, 36], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler142 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', maxAnisotropy: 1}); |
| try { |
| computePassEncoder153.setBindGroup(0, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer46, 'uint32', 1_160, 1_014); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup112); |
| } catch {} |
| let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout9, veryExplicitBindGroupLayout16]}); |
| let textureView195 = texture76.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 2}); |
| try { |
| computePassEncoder167.setPipeline(pipeline46); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup104); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer98, 'uint16', 1_400, 52); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(3, buffer119, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(1, bindGroup89); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let commandEncoder202 = device0.createCommandEncoder({}); |
| let texture203 = device0.createTexture({ |
| size: [60, 20, 23], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView196 = texture20.createView({}); |
| let computePassEncoder168 = commandEncoder202.beginComputePass({}); |
| let renderBundle27 = renderBundleEncoder27.finish({}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 323, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 14, y: 90, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 29, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline47 = device0.createRenderPipeline({ |
| layout: pipelineLayout10, |
| fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rgba8sint'}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'always', |
| stencilFront: {failOp: 'keep'}, |
| depthBias: -371920211, |
| depthBiasClamp: 364.17352260456823, |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 340, |
| attributes: [ |
| {format: 'sint32', offset: 108, shaderLocation: 8}, |
| {format: 'unorm8x4', offset: 32, shaderLocation: 5}, |
| {format: 'float16x4', offset: 4, shaderLocation: 13}, |
| {format: 'snorm16x2', offset: 36, shaderLocation: 14}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 4}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 44, shaderLocation: 7}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let gpuCanvasContext8 = offscreenCanvas6.getContext('webgpu'); |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let textureView197 = texture20.createView({}); |
| let textureView198 = texture80.createView({aspect: 'all'}); |
| try { |
| computePassEncoder168.setPipeline(pipeline40); |
| } catch {} |
| let texture204 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder121.setBindGroup(0, bindGroup108, new Uint32Array(6528), 2_685, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup89, new Uint32Array(392), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(185); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder37.setScissorRect(12, 4, 16, 10); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer130, 'uint32', 180, 629); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(0, undefined, 143_031_294, 476_982_073); |
| } catch {} |
| let autogeneratedBindGroupLayout82 = pipeline34.getBindGroupLayout(0); |
| let commandEncoder203 = device0.createCommandEncoder(); |
| let texture205 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 9}, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32sint'], |
| }); |
| let computePassEncoder169 = commandEncoder203.beginComputePass({}); |
| try { |
| computePassEncoder169.setPipeline(pipeline46); |
| } catch {} |
| try { |
| renderPassEncoder40.setPipeline(pipeline22); |
| } catch {} |
| let pipeline48 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}}); |
| document.body.append(canvas0); |
| let sampler143 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 62.95}); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup88); |
| } catch {} |
| try { |
| computePassEncoder136.setBindGroup(0, bindGroup92, new Uint32Array(1448), 113, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(1, bindGroup33, new Uint32Array(924), 315, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setScissorRect(27, 6, 0, 15); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer140 = device0.createBuffer({ |
| size: 3547, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder204 = device0.createCommandEncoder(); |
| let computePassEncoder170 = commandEncoder204.beginComputePass({}); |
| try { |
| computePassEncoder76.setBindGroup(2, bindGroup129, new Uint32Array(1955), 485, 0); |
| } catch {} |
| try { |
| computePassEncoder170.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(4, buffer90, 204); |
| } catch {} |
| try { |
| renderPassEncoder15.popDebugGroup(); |
| } catch {} |
| let commandEncoder205 = device0.createCommandEncoder({}); |
| let texture206 = device0.createTexture({ |
| size: [120, 40, 147], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder171 = commandEncoder205.beginComputePass({}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup98); |
| } catch {} |
| try { |
| computePassEncoder171.setPipeline(pipeline46); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup12, new Uint32Array(2451), 1_052, 0); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer87, 'uint32', 252, 567); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout83 = pipeline13.getBindGroupLayout(0); |
| let texture207 = device0.createTexture({ |
| size: [60, 20, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView199 = texture21.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 20}); |
| try { |
| computePassEncoder70.setBindGroup(3, bindGroup30, new Uint32Array(1201), 212, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup88, new Uint32Array(64), 29, 0); |
| } catch {} |
| try { |
| renderPassEncoder57.setIndexBuffer(buffer88, 'uint16', 1_238, 2_057); |
| } catch {} |
| try { |
| renderPassEncoder55.setPipeline(pipeline13); |
| } catch {} |
| let autogeneratedBindGroupLayout84 = pipeline1.getBindGroupLayout(0); |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup129, []); |
| } catch {} |
| try { |
| renderPassEncoder55.setBindGroup(1, bindGroup86); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer125, 'uint32', 20, 2_295); |
| } catch {} |
| try { |
| buffer126.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 26, y: 18 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 30, y: 13, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer141 = device0.createBuffer({size: 12940, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture208 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler144 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 79.81, |
| }); |
| try { |
| computePassEncoder159.setBindGroup(0, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(3, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer85, 'uint32', 340, 1_040); |
| } catch {} |
| try { |
| renderPassEncoder29.insertDebugMarker('\u81c2'); |
| } catch {} |
| let imageData35 = new ImageData(8, 220); |
| let pipelineLayout15 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout29]}); |
| let texture209 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder78.setBindGroup(0, bindGroup98); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup76, new Uint32Array(2604), 34, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder153); computePassEncoder153.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder53.executeBundles([renderBundle11, renderBundle8, renderBundle20, renderBundle3, renderBundle8, renderBundle26, renderBundle11, renderBundle7, renderBundle0, renderBundle8]); |
| } catch {} |
| try { |
| computePassEncoder78.pushDebugGroup('\u{1fc6f}'); |
| } catch {} |
| let pipeline49 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule3}}); |
| let bindGroup131 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout74, |
| entries: [{binding: 8, resource: {buffer: buffer84, offset: 0, size: 900}}], |
| }); |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup11, new Uint32Array(859), 230, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setScissorRect(41, 23, 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setVertexBuffer(0, buffer119, 0, 156); |
| } catch {} |
| try { |
| computePassEncoder32.pushDebugGroup('\uf97e'); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let imageData36 = new ImageData(12, 8); |
| let buffer142 = device0.createBuffer({size: 19318, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder166.setBindGroup(1, bindGroup123, new Uint32Array(750), 4, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let autogeneratedBindGroupLayout85 = pipeline13.getBindGroupLayout(0); |
| let commandEncoder206 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder49.setBindGroup(2, bindGroup25, new Uint32Array(4612), 971, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(0, buffer102, 1_272, 3_560); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| try { |
| commandEncoder206.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5280 */ |
| offset: 5280, |
| buffer: buffer110, |
| }, { |
| texture: texture183, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline50 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0xd6915e5}, |
| fragment: {module: shaderModule0, targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.RED}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilReadMask: 506772065, |
| stencilWriteMask: 504831740, |
| depthBiasSlopeScale: 669.9603252141269, |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {29_819: 0}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{format: 'snorm8x2', offset: 62, shaderLocation: 14}], |
| }, |
| { |
| arrayStride: 224, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32', offset: 64, shaderLocation: 4}, |
| {format: 'float16x4', offset: 168, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let buffer143 = device0.createBuffer({size: 20857, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder207 = device0.createCommandEncoder({}); |
| let textureView200 = texture137.createView({dimension: '2d-array'}); |
| let externalTexture30 = device0.importExternalTexture({source: videoFrame22}); |
| try { |
| computePassEncoder97.setBindGroup(2, bindGroup92); |
| } catch {} |
| try { |
| computePassEncoder128.setBindGroup(1, bindGroup123, new Uint32Array(2062), 963, 0); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let pipeline51 = device0.createRenderPipeline({ |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule1, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'equal', |
| stencilFront: {}, |
| stencilReadMask: 103727255, |
| stencilWriteMask: 3298489874, |
| depthBiasClamp: 974.2160391405555, |
| }, |
| vertex: {module: shaderModule0, entryPoint: 'vertex0', buffers: []}, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16'}, |
| }); |
| let autogeneratedBindGroupLayout86 = pipeline0.getBindGroupLayout(0); |
| let texture210 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 36}, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let computePassEncoder172 = commandEncoder207.beginComputePass(); |
| try { |
| computePassEncoder92.setBindGroup(2, bindGroup105, new Uint32Array(664), 81, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(6, buffer78); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame20, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 268, y: 24, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline52 = device0.createComputePipeline({layout: pipelineLayout10, compute: {module: shaderModule1, entryPoint: 'compute1'}}); |
| let buffer144 = device0.createBuffer({size: 12581, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder208 = device0.createCommandEncoder({}); |
| let textureView201 = texture89.createView({dimension: '2d'}); |
| let computePassEncoder173 = commandEncoder206.beginComputePass(); |
| try { |
| computePassEncoder114.setBindGroup(3, bindGroup58, []); |
| } catch {} |
| try { |
| computePassEncoder61.setBindGroup(3, bindGroup126, new Uint32Array(4389), 559, 0); |
| } catch {} |
| try { |
| computePassEncoder134.setPipeline(pipeline52); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup116); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(2, buffer112, 176); |
| } catch {} |
| try { |
| commandEncoder208.copyTextureToTexture({ |
| texture: texture205, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture186, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 3}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder208.resolveQuerySet(querySet16, 75, 55, buffer118, 4096); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| let texture211 = device0.createTexture({ |
| label: '\u6990\u0507\u09d9\u02ca\u{1ff91}\u{1fed4}', |
| size: [240, 80, 17], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder60 = commandEncoder208.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -302.9, g: 458.9, b: 176.5, a: -428.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder140.setBindGroup(0, bindGroup120); |
| } catch {} |
| try { |
| computePassEncoder143.setBindGroup(3, bindGroup126, new Uint32Array(2629), 124, 0); |
| } catch {} |
| try { |
| computePassEncoder173.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup55, new Uint32Array(1084), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer145 = device0.createBuffer({ |
| size: 5312, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture212 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView202 = texture99.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder121.setBindGroup(1, bindGroup105, new Uint32Array(2267), 734, 0); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(3, buffer123); |
| } catch {} |
| let commandEncoder209 = device0.createCommandEncoder({}); |
| let computePassEncoder174 = commandEncoder209.beginComputePass(); |
| let sampler145 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 79.14, |
| maxAnisotropy: 3, |
| }); |
| try { |
| computePassEncoder119.setBindGroup(1, bindGroup116); |
| } catch {} |
| try { |
| computePassEncoder153.end(); |
| } catch {} |
| try { |
| computePassEncoder174.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(313); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(7, buffer9, 2_136, 273); |
| } catch {} |
| try { |
| buffer127.unmap(); |
| } catch {} |
| let textureView203 = texture45.createView({}); |
| try { |
| renderPassEncoder46.setBindGroup(0, bindGroup43, new Uint32Array(3078), 500, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline23); |
| } catch {} |
| try { |
| commandEncoder182.copyBufferToBuffer(buffer59, 1292, buffer82, 484, 160); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| document.body.append(canvas0); |
| await gc(); |
| let imageBitmap8 = await createImageBitmap(imageData4); |
| let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpte240m', transfer: 'iec61966-2-1'} }); |
| let autogeneratedBindGroupLayout87 = pipeline11.getBindGroupLayout(0); |
| let texture213 = device0.createTexture({size: [120, 40, 1], sampleCount: 1, format: 'rgba8sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let textureView204 = texture23.createView({baseArrayLayer: 63, arrayLayerCount: 2}); |
| let computePassEncoder175 = commandEncoder182.beginComputePass(); |
| try { |
| renderPassEncoder58.setVertexBuffer(0, buffer78, 116, 704); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer61, 804, new Float32Array(7589), 196, 116); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas6, |
| origin: { x: 31, y: 40 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 203, y: 18, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder210 = device0.createCommandEncoder({}); |
| let computePassEncoder176 = commandEncoder210.beginComputePass({}); |
| try { |
| computePassEncoder72.setBindGroup(1, bindGroup83); |
| } catch {} |
| try { |
| computePassEncoder144.setBindGroup(2, bindGroup17, new Uint32Array(20), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder176.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| texture172.destroy(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| let bindGroup132 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout67, |
| entries: [{binding: 8, resource: {buffer: buffer97, offset: 256, size: 1348}}], |
| }); |
| let texture214 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 39}, |
| dimension: '2d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer40, 'uint16', 1_476, 10_086); |
| } catch {} |
| offscreenCanvas6.height = 201; |
| let bindGroup133 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout28, |
| entries: [{binding: 8, resource: {buffer: buffer53, offset: 1792, size: 60}}], |
| }); |
| let commandEncoder211 = device0.createCommandEncoder({}); |
| let renderPassEncoder61 = commandEncoder211.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: -231.2, g: 529.6, b: -968.9, a: 369.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 132773444, |
| }); |
| try { |
| computePassEncoder175.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder52.setViewport(48.653964723235184, 18.198302961824062, 58.11609631027509, 8.568049671428042, 0.41042642948179375, 0.5085771216177767); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer36, 'uint32', 2_628, 344); |
| } catch {} |
| offscreenCanvas5.height = 111; |
| let imageData37 = new ImageData(88, 24); |
| let texture215 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler146 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 38.73}); |
| try { |
| computePassEncoder172.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(6, buffer92, 248, 14); |
| } catch {} |
| try { |
| await buffer143.mapAsync(GPUMapMode.WRITE, 20856, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.insertDebugMarker('\u8a14'); |
| } catch {} |
| let autogeneratedBindGroupLayout88 = pipeline18.getBindGroupLayout(0); |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup132, new Uint32Array(2511), 529, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture140, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(10_037).fill(245), /* required buffer size: 10_037 */ |
| {offset: 105, bytesPerRow: 62, rowsPerImage: 31}, {width: 3, height: 6, depthOrArrayLayers: 6}); |
| } catch {} |
| let commandEncoder212 = device0.createCommandEncoder({}); |
| let texture216 = device0.createTexture({ |
| size: [60, 20, 17], |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder177 = commandEncoder212.beginComputePass({}); |
| try { |
| computePassEncoder177.setPipeline(pipeline40); |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(1, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer112, 'uint16', 310, 146); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 748, new DataView(new ArrayBuffer(11104)), 1731, 492); |
| } catch {} |
| let bindGroup134 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout39, |
| entries: [{binding: 8, resource: {buffer: buffer77, offset: 12288}}, {binding: 216, resource: textureView24}], |
| }); |
| let sampler147 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 78.15, |
| maxAnisotropy: 17, |
| }); |
| try { |
| buffer56.unmap(); |
| } catch {} |
| let textureView205 = texture73.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer28, 'uint16', 900, 1_777); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(5, undefined, 70_301_043); |
| } catch {} |
| try { |
| buffer138.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 14, y: 20 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 61, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 119, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture217 = device0.createTexture({ |
| size: [120, 40, 111], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView206 = texture176.createView({format: 'r32uint'}); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| let sampler148 = device0.createSampler({addressModeV: 'mirror-repeat', magFilter: 'linear', lodMaxClamp: 68.10}); |
| try { |
| computePassEncoder149.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder167.setBindGroup(0, bindGroup41, new Uint32Array(611), 78, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let bindGroup135 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 396, resource: {buffer: buffer32, offset: 5376}}], |
| }); |
| let commandEncoder213 = device0.createCommandEncoder({}); |
| let computePassEncoder178 = commandEncoder213.beginComputePass({}); |
| let sampler149 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 91.60}); |
| try { |
| computePassEncoder178.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(90); |
| } catch {} |
| try { |
| renderPassEncoder59.executeBundles([renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(3, buffer70, 0, 2_422); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| } catch {} |
| let recycledExplicitBindGroupLayout12 = pipeline15.getBindGroupLayout(1); |
| let buffer146 = device0.createBuffer({size: 6148, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView207 = texture151.createView({}); |
| let sampler150 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 76.50, |
| maxAnisotropy: 4, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup107, new Uint32Array(805), 136, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(6, buffer11, 0, 1_420); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(965).fill(40), /* required buffer size: 965 */ |
| {offset: 23, bytesPerRow: 27, rowsPerImage: 17}, {width: 6, height: 1, depthOrArrayLayers: 3}); |
| } catch {} |
| let commandEncoder214 = device0.createCommandEncoder({}); |
| let textureView208 = texture16.createView({aspect: 'depth-only', baseArrayLayer: 0}); |
| let sampler151 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 75.63, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder160.setBindGroup(1, bindGroup86, new Uint32Array(1676), 19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(2, bindGroup122); |
| } catch {} |
| let buffer147 = device0.createBuffer({ |
| size: 3714, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder215 = device0.createCommandEncoder({}); |
| let computePassEncoder179 = commandEncoder214.beginComputePass({}); |
| try { |
| computePassEncoder160.setBindGroup(0, bindGroup88); |
| } catch {} |
| try { |
| computePassEncoder112.setBindGroup(3, bindGroup93, new Uint32Array(145), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder179.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer88, 'uint16', 8_310, 139); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder59.setVertexBuffer(2, buffer147); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer46, 'uint16', 42, 719); |
| } catch {} |
| try { |
| commandEncoder215.copyBufferToBuffer(buffer132, 2640, buffer105, 2684, 368); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer116, 116, new Int16Array(3752), 30, 264); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData17, |
| origin: { x: 2, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 169, y: 7, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| let sampler152 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 95.78, |
| }); |
| try { |
| computePassEncoder117.setBindGroup(2, bindGroup5, new Uint32Array(326), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(7, buffer50); |
| } catch {} |
| try { |
| commandEncoder215.resolveQuerySet(querySet17, 19, 4, buffer82, 0); |
| } catch {} |
| let commandEncoder216 = device0.createCommandEncoder({}); |
| let renderBundle28 = renderBundleEncoder28.finish({}); |
| let sampler153 = device0.createSampler({}); |
| try { |
| computePassEncoder91.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup83, new Uint32Array(731), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder59.setBlendConstant({ r: -456.5, g: -259.7, b: 404.8, a: -475.7, }); |
| } catch {} |
| try { |
| renderPassEncoder60.setVertexBuffer(1, buffer4, 92); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let commandEncoder217 = device0.createCommandEncoder(); |
| let texture218 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rgba8sint', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder180 = commandEncoder215.beginComputePass({}); |
| try { |
| computePassEncoder173.setBindGroup(1, bindGroup52); |
| } catch {} |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup6, new Uint32Array(759), 199, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setViewport(27.361270955595643, 30.352101416743686, 191.85388495959475, 32.35837836912588, 0.9293116841448896, 0.9888556332623629); |
| } catch {} |
| try { |
| computePassEncoder58.setBindGroup(0, bindGroup71); |
| } catch {} |
| try { |
| computePassEncoder164.setBindGroup(3, bindGroup9, new Uint32Array(361), 66, 0); |
| } catch {} |
| try { |
| computePassEncoder180.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(3, bindGroup83); |
| } catch {} |
| try { |
| renderPassEncoder47.setIndexBuffer(buffer125, 'uint32', 832, 337); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(5, buffer98, 0, 95); |
| } catch {} |
| let imageData38 = new ImageData(68, 8); |
| let buffer148 = device0.createBuffer({size: 12340, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let querySet27 = device0.createQuerySet({type: 'occlusion', count: 85}); |
| let texture219 = device0.createTexture({ |
| size: [120, 40, 1], |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder94.setBindGroup(3, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder217.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 252 */ |
| offset: 252, |
| bytesPerRow: 256, |
| buffer: buffer58, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame25, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 53, y: 64, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout89 = pipeline31.getBindGroupLayout(0); |
| let commandEncoder218 = device0.createCommandEncoder({}); |
| let texture220 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder55.setBlendConstant({ r: -862.2, g: -144.4, b: 560.6, a: -191.2, }); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline23); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas2, |
| origin: { x: 176, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 53, y: 32, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 111, height: 21, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext9 = canvas3.getContext('webgpu'); |
| let videoFrame32 = new VideoFrame(offscreenCanvas4, {timestamp: 0}); |
| let commandEncoder219 = device0.createCommandEncoder({}); |
| let texture221 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView209 = texture141.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let computePassEncoder181 = commandEncoder219.beginComputePass({label: '\u984c\u5981\u030c\u0107\ufdfc\u41bc\u{1f9ff}\u1743\u0043\u0bcb'}); |
| let sampler154 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 65.05, |
| lodMaxClamp: 74.60, |
| compare: 'never', |
| maxAnisotropy: 3, |
| }); |
| try { |
| renderPassEncoder12.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| commandEncoder218.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1032 */ |
| offset: 1032, |
| rowsPerImage: 17, |
| buffer: buffer58, |
| }, { |
| texture: texture104, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder78.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(66).fill(103), /* required buffer size: 66 */ |
| {offset: 66}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder220 = device0.createCommandEncoder({}); |
| let texture222 = gpuCanvasContext4.getCurrentTexture(); |
| let computePassEncoder182 = commandEncoder217.beginComputePass({}); |
| try { |
| computePassEncoder182.setPipeline(pipeline45); |
| } catch {} |
| try { |
| renderPassEncoder48.setViewport(3.378161586462225, 5.535889073989733, 164.22955506998298, 38.12528119737974, 0.8989135278707341, 0.9675756884815044); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder221 = device0.createCommandEncoder({}); |
| let texture223 = device0.createTexture({size: [240], dimension: '1d', format: 'rg16sint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder183 = commandEncoder218.beginComputePass(); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup87, new Uint32Array(629), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setScissorRect(0, 0, 16, 4); |
| } catch {} |
| try { |
| renderPassEncoder32.setStencilReference(254); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer21, 'uint16', 4_578, 880); |
| } catch {} |
| try { |
| buffer33.unmap(); |
| } catch {} |
| document.body.prepend(img2); |
| let videoFrame33 = new VideoFrame(videoFrame23, {timestamp: 0}); |
| try { |
| computePassEncoder85.setBindGroup(0, bindGroup123); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderPassEncoder46.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer145, 'uint32', 1_444, 63); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData22, |
| origin: { x: 8, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 3, y: 51, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 24, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer149 = device0.createBuffer({size: 15617, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let textureView210 = texture206.createView({mipLevelCount: 1}); |
| let computePassEncoder184 = commandEncoder161.beginComputePass({label: '\u4981\u{1ff4b}\u5966\u4d9c'}); |
| let renderPassEncoder62 = commandEncoder220.beginRenderPass({ |
| label: '\u9e9f\u{1fde5}\u3bb0', |
| colorAttachments: [{ |
| view: textureView120, |
| clearValue: { r: 463.2, g: 68.87, b: -108.2, a: -787.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 99815464, |
| }); |
| try { |
| computePassEncoder79.setBindGroup(2, bindGroup95, new Uint32Array(122), 38, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder184.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(2, bindGroup55); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer44, 'uint32', 308, 207); |
| } catch {} |
| try { |
| computePassEncoder32.popDebugGroup(); |
| } catch {} |
| let buffer150 = device0.createBuffer({size: 10394, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let computePassEncoder185 = commandEncoder216.beginComputePass(); |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup133); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder183.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder54.executeBundles([renderBundle26]); |
| } catch {} |
| try { |
| renderPassEncoder47.setVertexBuffer(7, buffer147, 0); |
| } catch {} |
| try { |
| commandEncoder221.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 20 */ |
| offset: 8, |
| bytesPerRow: 18176, |
| buffer: buffer11, |
| }, { |
| texture: texture134, |
| mipLevel: 0, |
| origin: {x: 25, y: 1, z: 4}, |
| aspect: 'all', |
| }, {width: 3, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder221.clearBuffer(buffer116); |
| } catch {} |
| try { |
| computePassEncoder48.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 2, y: 11 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 599, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder222 = device0.createCommandEncoder({}); |
| let texture224 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder63 = commandEncoder221.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView81, |
| clearValue: { r: 932.7, g: 654.7, b: 244.2, a: -302.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: {view: textureView20, depthLoadOp: 'load', depthStoreOp: 'store'}, |
| }); |
| try { |
| computePassEncoder78.setBindGroup(1, bindGroup5, new Uint32Array(1587), 222, 0); |
| } catch {} |
| try { |
| renderPassEncoder40.setIndexBuffer(buffer113, 'uint32', 15_012, 371); |
| } catch {} |
| document.body.prepend(canvas1); |
| let recycledAutogeneratedBindGroupLayout3 = pipeline35.getBindGroupLayout(0); |
| let commandEncoder223 = device0.createCommandEncoder(); |
| let textureView211 = texture165.createView({}); |
| let computePassEncoder186 = commandEncoder223.beginComputePass(); |
| let sampler155 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 89.29, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder185.setPipeline(pipeline42); |
| } catch {} |
| try { |
| commandEncoder222.copyTextureToTexture({ |
| texture: texture134, |
| mipLevel: 1, |
| origin: {x: 22, y: 5, z: 8}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 23, y: 5, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 45, y: 25, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder224 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder51.setBindGroup(2, bindGroup120, new Uint32Array(7386), 1_009, 0); |
| } catch {} |
| try { |
| renderPassEncoder58.executeBundles([renderBundle9, renderBundle16]); |
| } catch {} |
| let commandEncoder225 = device0.createCommandEncoder({}); |
| let textureView212 = texture64.createView({format: 'rgba8sint', mipLevelCount: 1}); |
| let renderPassEncoder64 = commandEncoder222.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView81, |
| clearValue: { r: 329.1, g: 32.37, b: -963.3, a: -457.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView151, |
| depthClearValue: 0.18430521564793967, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'store', |
| depthReadOnly: false, |
| }, |
| }); |
| let sampler156 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMinClamp: 4.464, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder183.setBindGroup(0, bindGroup23, new Uint32Array(4605), 104, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setScissorRect(5, 2, 8, 2); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder224.copyTextureToBuffer({ |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 16, y: 4, z: 16}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1440 */ |
| offset: 1440, |
| buffer: buffer37, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder119.insertDebugMarker('\u01ff'); |
| } catch {} |
| let bindGroup136 = device0.createBindGroup({ |
| layout: recycledAutogeneratedBindGroupLayout2, |
| entries: [{binding: 8, resource: {buffer: buffer133, offset: 4352, size: 856}}], |
| }); |
| let buffer151 = device0.createBuffer({size: 13855, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let computePassEncoder187 = commandEncoder224.beginComputePass({}); |
| let sampler157 = device0.createSampler({ |
| label: '\u{1fe27}\u6cc9\uba16\u6b16', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMaxClamp: 74.76, |
| }); |
| try { |
| computePassEncoder97.setBindGroup(2, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup125); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup26, new Uint32Array(3466), 1_576, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u0cff'); |
| } catch {} |
| let autogeneratedBindGroupLayout90 = pipeline29.getBindGroupLayout(0); |
| let bindGroup137 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout7, |
| entries: [{binding: 8, resource: {buffer: buffer17, offset: 256}}], |
| }); |
| let commandEncoder226 = device0.createCommandEncoder(); |
| let texture225 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 6}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder65 = commandEncoder225.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView54, |
| clearValue: { r: 813.0, g: -506.7, b: 731.4, a: -377.5, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView58, |
| depthLoadOp: 'load', |
| depthStoreOp: 'store', |
| depthReadOnly: false, |
| stencilReadOnly: true, |
| }, |
| occlusionQuerySet: querySet26, |
| maxDrawCount: 340642567, |
| }); |
| try { |
| await buffer45.mapAsync(GPUMapMode.READ, 0, 1240); |
| } catch {} |
| try { |
| commandEncoder226.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3432 */ |
| offset: 3432, |
| buffer: buffer62, |
| }, { |
| texture: texture183, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture183, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(209).fill(203), /* required buffer size: 209 */ |
| {offset: 209}, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| adapter0.label = '\u3e09\u68f6'; |
| } catch {} |
| let commandEncoder227 = device0.createCommandEncoder({}); |
| let textureView213 = texture67.createView({dimension: 'cube', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 6}); |
| try { |
| computePassEncoder120.setBindGroup(2, bindGroup129); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroupsIndirect(buffer15, 7_436); }; |
| } catch {} |
| try { |
| computePassEncoder187.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer78, 'uint16', 220, 928); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(5, buffer73, 1_056); |
| } catch {} |
| try { |
| commandEncoder227.copyBufferToBuffer(buffer132, 2688, buffer112, 120, 572); |
| } catch {} |
| try { |
| commandEncoder227.copyTextureToBuffer({ |
| texture: texture112, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4272 */ |
| offset: 4272, |
| bytesPerRow: 29184, |
| buffer: buffer0, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler158 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 68.91}); |
| try { |
| renderPassEncoder49.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer146, 'uint32', 1_900, 385); |
| } catch {} |
| try { |
| commandEncoder226.copyBufferToBuffer(buffer145, 332, buffer64, 1900, 316); |
| } catch {} |
| try { |
| commandEncoder227.insertDebugMarker('\u0622'); |
| } catch {} |
| let pipeline53 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4, entryPoint: 'compute4'}}); |
| let commandEncoder228 = device0.createCommandEncoder({}); |
| let texture226 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView214 = texture50.createView({baseArrayLayer: 2, arrayLayerCount: 1}); |
| let computePassEncoder188 = commandEncoder228.beginComputePass({}); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup88, new Uint32Array(8577), 4_610, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture204, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(190).fill(51), /* required buffer size: 190 */ |
| {offset: 190, bytesPerRow: 12}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture227 = device0.createTexture({size: [120, 40, 1], format: 'rg32sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView215 = texture69.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 1}); |
| let computePassEncoder189 = commandEncoder226.beginComputePass({}); |
| try { |
| computePassEncoder186.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup81); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer62, 'uint16', 3_354, 7_798); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData39 = new ImageData(20, 36); |
| try { |
| globalThis.someLabel = externalTexture7.label; |
| } catch {} |
| let bindGroup138 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout58, |
| entries: [{binding: 8, resource: {buffer: buffer41, offset: 1536, size: 2192}}], |
| }); |
| let commandEncoder229 = device0.createCommandEncoder(); |
| let textureView216 = texture124.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 4}); |
| try { |
| computePassEncoder188.setPipeline(pipeline40); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup58, new Uint32Array(539), 257, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer28, 'uint16', 508, 2_645); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(7, buffer82, 0, 365); |
| } catch {} |
| let promise25 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder230 = device0.createCommandEncoder({}); |
| let texture228 = device0.createTexture({ |
| label: '\u85bb\u{1fbc5}\u02cc\u477b\u5dde\u5752\ua401', |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler159 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.00, |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer82, 'uint16', 98, 410); |
| } catch {} |
| let promise26 = device0.queue.onSubmittedWorkDone(); |
| document.body.append(img3); |
| let querySet28 = device0.createQuerySet({type: 'occlusion', count: 159}); |
| let computePassEncoder190 = commandEncoder227.beginComputePass({}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup112, new Uint32Array(1076), 41, 0); |
| } catch {} |
| try { |
| computePassEncoder190.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup113); |
| } catch {} |
| try { |
| renderPassEncoder30.executeBundles([]); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| commandEncoder229.resolveQuerySet(querySet19, 46, 15, buffer48, 0); |
| } catch {} |
| document.body.prepend(canvas2); |
| let computePassEncoder191 = commandEncoder230.beginComputePass({}); |
| try { |
| renderPassEncoder22.setViewport(44.930310466230836, 6.923339642883796, 11.244319517975956, 0.7826121409801033, 0.22047430715691718, 0.24935676140960733); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer9, 0, 1_340); |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let recycledExplicitBindGroupLayout13 = pipeline40.getBindGroupLayout(0); |
| let bindGroup139 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [{binding: 53, resource: {buffer: buffer39, offset: 2560, size: 104}}], |
| }); |
| let texture229 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder116.setBindGroup(1, bindGroup89); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(2, 2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(48); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer128, 'uint32', 344, 483); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(6, buffer125, 256, 1_301); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder229.resolveQuerySet(querySet0, 138, 44, buffer118, 31488); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let querySet29 = device0.createQuerySet({type: 'occlusion', count: 345}); |
| let textureView217 = texture129.createView({ |
| label: '\u0a8c\u3ded\u9d80\u0ef7\u0f7e\ud1e5', |
| dimension: 'cube-array', |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| let computePassEncoder192 = commandEncoder229.beginComputePass({}); |
| let externalTexture31 = device0.importExternalTexture({source: videoFrame28, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder181.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer36, 'uint32', 144, 61); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer84, 516, new Float32Array(1419), 133, 136); |
| } catch {} |
| let autogeneratedBindGroupLayout91 = pipeline19.getBindGroupLayout(0); |
| let bindGroup140 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout18, |
| entries: [{binding: 8, resource: {buffer: buffer123, offset: 512, size: 308}}], |
| }); |
| let texture230 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView218 = texture212.createView({}); |
| try { |
| computePassEncoder33.setBindGroup(2, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup125); |
| } catch {} |
| try { |
| renderPassEncoder42.beginOcclusionQuery(247); |
| } catch {} |
| try { |
| buffer115.unmap(); |
| } catch {} |
| let promise27 = device0.queue.onSubmittedWorkDone(); |
| let pipeline54 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule5, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'always', depthFailOp: 'keep'}, |
| stencilBack: {}, |
| stencilReadMask: 27698065, |
| stencilWriteMask: 1709583292, |
| depthBiasSlopeScale: 204.22366671074286, |
| }, |
| vertex: { |
| module: shaderModule3, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'uint8x2', offset: 0, shaderLocation: 2}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 12}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint32', offset: 0, shaderLocation: 4}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 6}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 8}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 10}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 5}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 0}, |
| {format: 'sint32', offset: 0, shaderLocation: 15}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 14}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 7}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw'}, |
| }); |
| let bindGroup141 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 8, resource: {buffer: buffer140, offset: 1280, size: 116}}], |
| }); |
| let texture231 = device0.createTexture({ |
| size: [240, 80, 294], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder101.setBindGroup(0, bindGroup20, new Uint32Array(634), 41, 0); |
| } catch {} |
| try { |
| computePassEncoder85.end(); |
| } catch {} |
| try { |
| renderPassEncoder42.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer22, 'uint16', 12_284, 5_246); |
| } catch {} |
| try { |
| commandEncoder98.copyBufferToTexture({ |
| /* bytesInLastRow: 192 widthInBlocks: 48 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1160 */ |
| offset: 1160, |
| bytesPerRow: 256, |
| buffer: buffer33, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 14, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 48, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder98.resolveQuerySet(querySet29, 18, 119, buffer100, 5888); |
| } catch {} |
| let recycledExplicitBindGroupLayout14 = pipeline46.getBindGroupLayout(0); |
| let renderPassEncoder66 = commandEncoder98.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView218, |
| depthSlice: 217, |
| clearValue: { r: 37.89, g: 198.0, b: -254.1, a: 264.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 253367466, |
| }); |
| try { |
| computePassEncoder107.setBindGroup(3, bindGroup141); |
| } catch {} |
| try { |
| computePassEncoder191.setPipeline(pipeline7); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(158).fill(70), /* required buffer size: 158 */ |
| {offset: 158}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline55 = device0.createComputePipeline({ |
| label: '\u4574\u{1fee2}\ucd55', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}, |
| }); |
| let veryExplicitBindGroupLayout30 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 105, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 343, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let recycledExplicitBindGroupLayout15 = pipeline25.getBindGroupLayout(1); |
| let bindGroup142 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout8, |
| entries: [{binding: 8, resource: {buffer: buffer129, offset: 0}}], |
| }); |
| let commandEncoder231 = device0.createCommandEncoder({}); |
| let texture232 = device0.createTexture({ |
| size: {width: 30}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder58.end(); |
| } catch {} |
| try { |
| renderPassEncoder42.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let arrayBuffer13 = buffer45.getMappedRange(0, 148); |
| let commandEncoder232 = device0.createCommandEncoder({}); |
| let querySet30 = device0.createQuerySet({type: 'occlusion', count: 717}); |
| let renderPassEncoder67 = commandEncoder67.beginRenderPass({colorAttachments: [{view: textureView15, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| computePassEncoder103.setBindGroup(3, bindGroup81, new Uint32Array(1854), 194, 0); |
| } catch {} |
| let buffer152 = device0.createBuffer({size: 9374, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let textureView219 = texture45.createView({baseMipLevel: 0}); |
| let texture233 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView220 = texture39.createView({dimension: '2d', baseArrayLayer: 3}); |
| let renderPassEncoder68 = commandEncoder231.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView120, |
| clearValue: { r: -575.9, g: 0.5620, b: -574.5, a: 814.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder186.setBindGroup(2, bindGroup136, new Uint32Array(498), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer78, 'uint16', 298, 458); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(0, buffer97, 1_112); |
| } catch {} |
| try { |
| commandEncoder232.copyBufferToBuffer(buffer85, 60, buffer4, 2512, 452); |
| } catch {} |
| let veryExplicitBindGroupLayout31 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 43, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 57, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 132, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 774, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture234 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 12}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView221 = texture224.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder193 = commandEncoder232.beginComputePass({}); |
| try { |
| computePassEncoder119.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup123, new Uint32Array(1204), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer53, 'uint16', 2_446, 314); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(2, buffer112); |
| } catch {} |
| try { |
| buffer64.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 3672, new DataView(new ArrayBuffer(6638)), 1586, 220); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder233 = device0.createCommandEncoder({}); |
| let computePassEncoder194 = commandEncoder233.beginComputePass({label: '\u01b2\u01fc\u{1fb78}\u8db7\u0f6d\ue9d2\u0104\u0641\ub359'}); |
| let externalTexture32 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder130.setBindGroup(1, bindGroup113); |
| } catch {} |
| try { |
| computePassEncoder193.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(3, bindGroup86, new Uint32Array(7234), 6_043, 0); |
| } catch {} |
| let arrayBuffer14 = buffer65.getMappedRange(1200, 32); |
| let texture235 = device0.createTexture({ |
| size: [120, 40, 16], |
| mipLevelCount: 2, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture236 = gpuCanvasContext5.getCurrentTexture(); |
| try { |
| computePassEncoder113.setBindGroup(1, bindGroup86); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer44, 'uint32', 112, 19); |
| } catch {} |
| try { |
| renderPassEncoder68.setVertexBuffer(2, buffer129); |
| } catch {} |
| try { |
| renderPassEncoder58.insertDebugMarker('\u0cf3'); |
| } catch {} |
| try { |
| await promise26; |
| } catch {} |
| try { |
| adapter0.label = '\u0325\u{1f6d4}\u8734'; |
| } catch {} |
| try { |
| externalTexture27.label = '\ufbd7\u7505\u090c\u0dd1\u2c1e\u{1f926}\u0e4d\u0777\u13af\u0463\u02f5'; |
| } catch {} |
| let bindGroup143 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [{binding: 8, resource: {buffer: buffer89, offset: 0, size: 188}}], |
| }); |
| let commandEncoder234 = device0.createCommandEncoder({}); |
| let commandBuffer17 = commandEncoder234.finish(); |
| let textureView222 = texture132.createView({}); |
| let sampler160 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder192.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder52.executeBundles([renderBundle12, renderBundle9]); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer17]); |
| } catch {} |
| let commandEncoder235 = device0.createCommandEncoder({}); |
| let textureView223 = texture0.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let computePassEncoder195 = commandEncoder235.beginComputePass(); |
| let sampler161 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 75.71, |
| }); |
| try { |
| computePassEncoder189.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder22.beginOcclusionQuery(52); |
| } catch {} |
| try { |
| renderPassEncoder22.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder52.executeBundles([renderBundle7, renderBundle16]); |
| } catch {} |
| let recycledExplicitBindGroupLayout16 = pipeline5.getBindGroupLayout(0); |
| let buffer153 = device0.createBuffer({ |
| size: 1612, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler162 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder121.setBindGroup(2, bindGroup22, new Uint32Array(265), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder63.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder35.setBlendConstant({ r: -147.2, g: 409.7, b: -481.4, a: 658.6, }); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(7, buffer34, 0, 760); |
| } catch {} |
| let querySet31 = device0.createQuerySet({type: 'occlusion', count: 354}); |
| try { |
| computePassEncoder164.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder91.setBindGroup(0, bindGroup107, new Uint32Array(658), 76, 0); |
| } catch {} |
| try { |
| computePassEncoder195.setPipeline(pipeline36); |
| } catch {} |
| try { |
| await promise27; |
| } catch {} |
| let bindGroup144 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout15, |
| entries: [{binding: 8, resource: {buffer: buffer93, offset: 768}}], |
| }); |
| let commandEncoder236 = device0.createCommandEncoder({}); |
| let texture237 = device0.createTexture({ |
| size: [240], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder196 = commandEncoder236.beginComputePass({}); |
| let externalTexture33 = device0.importExternalTexture({source: videoFrame31}); |
| let pipeline56 = await device0.createComputePipelineAsync({layout: pipelineLayout7, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| let canvas4 = document.createElement('canvas'); |
| let videoFrame34 = new VideoFrame(videoFrame12, {timestamp: 0}); |
| let commandEncoder237 = device0.createCommandEncoder({}); |
| let textureView224 = texture74.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let renderPassEncoder69 = commandEncoder237.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView81, |
| clearValue: { r: -500.8, g: -207.3, b: -711.0, a: 430.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: { |
| view: textureView155, |
| depthClearValue: 1.583889143093831, |
| depthLoadOp: 'load', |
| depthStoreOp: 'store', |
| stencilClearValue: 59128, |
| }, |
| }); |
| try { |
| computePassEncoder194.setPipeline(pipeline15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 32, new Int16Array(39510), 5044, 300); |
| } catch {} |
| let bindGroup145 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout29, |
| entries: [ |
| {binding: 198, resource: {buffer: buffer23, offset: 256, size: 1028}}, |
| {binding: 72, resource: textureView137}, |
| ], |
| }); |
| let textureView225 = texture67.createView({dimension: 'cube', aspect: 'all', arrayLayerCount: 6}); |
| let textureView226 = texture76.createView({baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup130); |
| } catch {} |
| try { |
| computePassEncoder196.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer24, 'uint16', 3_502, 15_158); |
| } catch {} |
| try { |
| adapter0.label = '\u9efb\uc717\u11b0\ud166\u35c9\u{1fd56}\u{1fa6c}\u9701'; |
| } catch {} |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| let sampler163 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 75.72, |
| compare: 'always', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder161.setBindGroup(2, bindGroup25, []); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(4); |
| } catch {} |
| let buffer154 = device0.createBuffer({size: 8848, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder238 = device0.createCommandEncoder({}); |
| let textureView227 = texture147.createView({}); |
| let computePassEncoder197 = commandEncoder238.beginComputePass({}); |
| try { |
| computePassEncoder197.setPipeline(pipeline0); |
| } catch {} |
| let gpuCanvasContext10 = canvas4.getContext('webgpu'); |
| let buffer155 = device0.createBuffer({size: 6794, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let sampler164 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 73.95, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder96.setBindGroup(0, bindGroup138, new Uint32Array(1782), 50, 0); |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder65.setBindGroup(3, bindGroup130); |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(69); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer147, 'uint16', 136, 416); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 1480, new Int16Array(17144), 4999, 716); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData14, |
| origin: { x: 0, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 13, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| sampler101.label = '\u7df1\u0658\uf74c\ucb0a\u8609\u04cd\uf408\ub0bc'; |
| } catch {} |
| let texture238 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup114, new Uint32Array(122), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(1, bindGroup117); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(3, bindGroup41, new Uint32Array(345), 180, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(3, buffer59); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 2, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 49, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'bt1361ExtendedColourGamut'} }); |
| let recycledAutogeneratedBindGroupLayout4 = pipeline30.getBindGroupLayout(0); |
| let buffer156 = device0.createBuffer({size: 27363, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let externalTexture34 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder67.setBindGroup(2, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(2, bindGroup94); |
| } catch {} |
| try { |
| renderPassEncoder49.beginOcclusionQuery(216); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(1, bindGroup111, []); |
| } catch {} |
| try { |
| computePassEncoder78.insertDebugMarker('\u{1fca1}'); |
| } catch {} |
| let videoFrame36 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte240m', transfer: 'linear'} }); |
| let bindGroup146 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [{binding: 8, resource: {buffer: buffer108, offset: 512, size: 584}}], |
| }); |
| try { |
| renderPassEncoder57.setScissorRect(46, 9, 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(0, buffer26, 612, 2_277); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer89, 'uint32', 60, 177); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let img4 = await imageWithData(38, 62, '#10101010', '#20202020'); |
| let bindGroup147 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout39, |
| entries: [ |
| {binding: 216, resource: textureView24}, |
| {binding: 8, resource: {buffer: buffer61, offset: 256, size: 800}}, |
| ], |
| }); |
| let pipelineLayout16 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout51]}); |
| let textureView228 = texture103.createView({baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder135.setBindGroup(1, bindGroup115, new Uint32Array(528), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(2, bindGroup99); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(3, bindGroup10, new Uint32Array(612), 60, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer116, 552, new Int16Array(715), 18, 36); |
| } catch {} |
| try { |
| if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55); }; |
| } catch {} |
| let querySet32 = device0.createQuerySet({type: 'occlusion', count: 1299}); |
| try { |
| computePassEncoder163.setBindGroup(0, bindGroup85, new Uint32Array(165), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder69.setIndexBuffer(buffer46, 'uint16', 456, 173); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(4, buffer43); |
| } catch {} |
| try { |
| renderPassEncoder68.setBindGroup(1, bindGroup109); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup78, new Uint32Array(619), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer64, 0, 2_661); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(0, bindGroup88); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(3, bindGroup71, new Uint32Array(458), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer46, 'uint32', 1_072, 642); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(5, buffer8, 136, 664); |
| } catch {} |
| let sampler165 = device0.createSampler({addressModeV: 'mirror-repeat'}); |
| try { |
| computePassEncoder61.setBindGroup(1, bindGroup108); |
| } catch {} |
| try { |
| renderPassEncoder49.endOcclusionQuery(); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer94, 'uint32', 208, 15); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(6, buffer82, 60, 307); |
| } catch {} |
| let pipeline57 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment5', |
| constants: {}, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilReadMask: 915801827, |
| stencilWriteMask: 207860342, |
| depthBias: -1967931460, |
| depthBiasClamp: 0.0, |
| }, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 144, |
| attributes: [ |
| {format: 'float32x4', offset: 4, shaderLocation: 7}, |
| {format: 'unorm16x2', offset: 40, shaderLocation: 0}, |
| {format: 'unorm16x4', offset: 20, shaderLocation: 2}, |
| {format: 'float16x2', offset: 24, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 13}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| document.body.append(img2); |
| let recycledExplicitBindGroupLayout17 = pipeline46.getBindGroupLayout(0); |
| try { |
| computePassEncoder104.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(0, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder40.setPipeline(pipeline39); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(1, bindGroup66); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture234, |
| mipLevel: 0, |
| origin: {x: 37, y: 14, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(259).fill(226), /* required buffer size: 259 */ |
| {offset: 175, bytesPerRow: 56, rowsPerImage: 80}, {width: 7, height: 2, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let renderBundle29 = renderBundleEncoder29.finish({}); |
| try { |
| renderPassEncoder38.setBindGroup(3, bindGroup127, new Uint32Array(252), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder55.setIndexBuffer(buffer28, 'uint16', 154, 576); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(6, buffer78, 0); |
| } catch {} |
| try { |
| buffer64.unmap(); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture32.label; |
| } catch {} |
| let commandEncoder239 = device0.createCommandEncoder({}); |
| let texture239 = device0.createTexture({ |
| size: [30, 10, 36], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder198 = commandEncoder239.beginComputePass({}); |
| try { |
| renderPassEncoder59.setBindGroup(2, bindGroup123, new Uint32Array(1875), 472, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer99, 'uint32', 492, 701); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline47); |
| } catch {} |
| let texture240 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 158}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder77.setBindGroup(1, bindGroup113); |
| } catch {} |
| try { |
| computePassEncoder100.setBindGroup(1, bindGroup28, new Uint32Array(1340), 368, 0); |
| } catch {} |
| try { |
| computePassEncoder198.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer156, 'uint16', 650, 3_179); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(3, buffer151, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture176, |
| mipLevel: 0, |
| origin: {x: 45, y: 28, z: 92}, |
| aspect: 'all', |
| }, new Uint8Array(87_910).fill(20), /* required buffer size: 87_910 */ |
| {offset: 52, bytesPerRow: 185, rowsPerImage: 6}, {width: 42, height: 1, depthOrArrayLayers: 80}); |
| } catch {} |
| let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout72]}); |
| let commandEncoder240 = device0.createCommandEncoder({}); |
| let texture241 = device0.createTexture({size: [60, 20, 1], format: 'rg8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let textureView229 = texture225.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1}); |
| let renderPassEncoder70 = commandEncoder240.beginRenderPass({ |
| colorAttachments: [{view: textureView218, depthSlice: 89, loadOp: 'clear', storeOp: 'discard'}], |
| maxDrawCount: 59033494, |
| }); |
| let externalTexture35 = device0.importExternalTexture({source: videoFrame32}); |
| try { |
| renderPassEncoder52.setIndexBuffer(buffer85, 'uint32', 1_032, 124); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 13, y: 11, z: 121}, |
| aspect: 'all', |
| }, new Uint8Array(264_665).fill(80), /* required buffer size: 264_665 */ |
| {offset: 183, bytesPerRow: 282, rowsPerImage: 50}, {width: 31, height: 38, depthOrArrayLayers: 19}); |
| } catch {} |
| let pipeline58 = await device0.createComputePipelineAsync({ |
| label: '\u0489\u56e1\u73e1\u9b8e', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule4, entryPoint: 'compute5', constants: {}}, |
| }); |
| let commandEncoder241 = device0.createCommandEncoder({}); |
| let querySet33 = device0.createQuerySet({type: 'occlusion', count: 1160}); |
| let computePassEncoder199 = commandEncoder241.beginComputePass({}); |
| let sampler166 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 87.34}); |
| try { |
| renderPassEncoder63.setViewport(41.662498089320465, 2.4357921972925256, 54.02276230818051, 17.76571019875878, 0.4035118060563496, 0.6322843261110258); |
| } catch {} |
| try { |
| renderPassEncoder63.setPipeline(pipeline22); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| @id(51249) override override22 = -662; |
| |
| override override24: f32; |
| |
| override override16: i32 = 3; |
| |
| @id(6430) override override5: f16 = 333.7; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @id(58061) override override20: u32; |
| |
| @id(13133) override override21: i32; |
| |
| @id(7538) override override15: u32; |
| |
| @group(0) @binding(8) var<storage, read> buffer157: array<array<array<array<f16, 9>, 1>, 3>>; |
| |
| override override12: f32; |
| |
| override override18: f16; |
| |
| struct T0 { |
| @size(56) f0: array<u32>, |
| } |
| |
| @id(46193) override override9: f32; |
| |
| override override13: f16 = -45456.8; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct FragmentOutput6 { |
| @location(0) @interpolate(flat) f0: vec4i, |
| @location(3) f1: vec2i, |
| @location(7) @interpolate(flat) f2: i32, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| override override8 = -0.2608; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| override override7 = true; |
| |
| override override14: f16; |
| |
| fn fn0() -> mat3x3h { |
| var out: mat3x3h; |
| var vf62: vec4h = asin(vec4h(unconst_f16(190.7), unconst_f16(33354.5), unconst_f16(7114.7), unconst_f16(5229.0))); |
| let ptr111: ptr<storage, array<array<f16, 9>, 1>, read> = &(*&buffer157)[arrayLength(&(*&buffer157))][2]; |
| let ptr112: ptr<storage, array<array<array<f16, 9>, 1>, 3>, read> = &(*&buffer157)[arrayLength(&(*&buffer157)) - 1]; |
| let ptr113: ptr<storage, array<f16, 9>, read> = &(*ptr111)[u32(unconst_u32(124))]; |
| vf62 -= vec4h((*&buffer157)[u32(unconst_u32(464))][u32(unconst_u32(0))][0][u32(unconst_u32(64))]); |
| let vf63: f32 = override12; |
| let ptr114: ptr<storage, array<array<f16, 9>, 1>, read> = &(*ptr112)[u32(unconst_u32(443))]; |
| out = mat3x3h((*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8], (*&buffer157)[u32(unconst_u32(161))][2][0][8]); |
| vf62 *= sin(vec3h(unconst_f16(10476.6), unconst_f16(10.15), unconst_f16(1243.0))).rbrb; |
| return out; |
| _ = override12; |
| _ = buffer157; |
| } |
| |
| override override23: i32 = 168; |
| |
| override override17: i32; |
| |
| @id(56410) override override10: f16 = 8724.9; |
| |
| override override6: f16 = 1533.0; |
| |
| var<workgroup> vw27: mat2x4h; |
| |
| override override19: u32; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| override override11: u32 = 215; |
| |
| @fragment |
| fn fragment6() -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| fn0(); |
| out.f2 = i32((*&buffer157)[u32(unconst_u32(130))][u32(unconst_u32(70))][u32(unconst_u32(26))][8]); |
| var vf64 = fn0(); |
| let ptr115: ptr<storage, array<f16, 9>, read> = &(*&buffer157)[vec3u(vf64[unconst_i32(1)])[1]][u32(unconst_u32(94))][u32(unconst_u32(218))]; |
| let ptr116: ptr<storage, f16, read> = &(*ptr115)[u32(unconst_u32(55))]; |
| let ptr117: ptr<storage, array<array<array<f16, 9>, 1>, 3>, read> = &buffer157[u32(unconst_u32(82))]; |
| var vf65 = fn0(); |
| fn0(); |
| let ptr118: ptr<storage, f16, read> = &buffer157[arrayLength(&buffer157)][2][0][u32(unconst_u32(46))]; |
| let ptr119: ptr<storage, array<array<f16, 9>, 1>, read> = &buffer157[arrayLength(&buffer157)][u32(unconst_u32(211))]; |
| fn0(); |
| var vf66 = fn0(); |
| let ptr120: ptr<storage, array<f16, 9>, read> = &(*&buffer157)[arrayLength(&(*&buffer157))][2][u32(unconst_u32(150))]; |
| return out; |
| _ = override12; |
| _ = buffer157; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute7() { |
| let vf67: f32 = override9; |
| vw27 = mat2x4h(buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))], buffer157[u32(unconst_u32(179))][2][u32(unconst_u32(59))][u32(unconst_u32(95))]); |
| vw27 = mat2x4h((*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(65))][0][8]); |
| vw27 = mat2x4h((*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))], (*&buffer157)[arrayLength(&(*&buffer157))][u32(unconst_u32(197))][u32(unconst_u32(414))][u32(unconst_u32(270))]); |
| var vf68 = fn0(); |
| let ptr121: ptr<storage, array<array<array<f16, 9>, 1>, 3>, read> = &buffer157[u32(unconst_u32(419))]; |
| let ptr122: ptr<storage, f16, read> = &(*&buffer157)[arrayLength(&(*&buffer157))][2][u32((*&buffer157)[arrayLength(&(*&buffer157))][2][u32(unconst_u32(185))][8])][8]; |
| var vf69 = fn0(); |
| _ = override12; |
| _ = override9; |
| _ = buffer157; |
| }`, |
| }); |
| let texture242 = gpuCanvasContext0.getCurrentTexture(); |
| let sampler167 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 84.29}); |
| try { |
| computePassEncoder199.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(5, buffer120, 0, 667); |
| } catch {} |
| let arrayBuffer15 = buffer1.getMappedRange(80, 0); |
| document.body.prepend(canvas2); |
| let recycledExplicitBindGroupLayout18 = pipeline39.getBindGroupLayout(0); |
| let commandEncoder242 = device0.createCommandEncoder({}); |
| let textureView230 = texture124.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture243 = device0.createTexture({ |
| size: [60, 20, 29], |
| mipLevelCount: 3, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView231 = texture49.createView({format: 'rgba8sint', baseMipLevel: 0}); |
| let computePassEncoder200 = commandEncoder242.beginComputePass({}); |
| try { |
| computePassEncoder113.setBindGroup(0, bindGroup58, new Uint32Array(449), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(3, bindGroup13, new Uint32Array(2163), 135, 0); |
| } catch {} |
| try { |
| renderPassEncoder69.setScissorRect(0, 18, 25, 9); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(6, buffer115, 0, 561); |
| } catch {} |
| let texture244 = device0.createTexture({ |
| size: [30, 10, 1], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView232 = texture110.createView({aspect: 'all', arrayLayerCount: 1}); |
| let sampler168 = device0.createSampler({ |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder128.setBindGroup(0, bindGroup82, new Uint32Array(2519), 110, 0); |
| } catch {} |
| try { |
| computePassEncoder200.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder16.setBlendConstant({ r: 66.69, g: 605.0, b: 144.4, a: 702.9, }); |
| } catch {} |
| try { |
| buffer90.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let bindGroup148 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [{binding: 8, resource: {buffer: buffer41, offset: 1792, size: 2428}}], |
| }); |
| let commandEncoder243 = device0.createCommandEncoder({}); |
| let textureView233 = texture178.createView({arrayLayerCount: 2}); |
| let renderPassEncoder71 = commandEncoder243.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView71, |
| clearValue: { r: 780.3, g: -540.4, b: -45.45, a: -864.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet11, |
| }); |
| try { |
| renderPassEncoder54.setIndexBuffer(buffer87, 'uint32', 240, 1_022); |
| } catch {} |
| document.body.append(img1); |
| let commandEncoder244 = device0.createCommandEncoder({}); |
| let texture245 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 16}, |
| mipLevelCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler169 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 88.73, |
| }); |
| try { |
| renderPassEncoder57.setIndexBuffer(buffer112, 'uint16', 650, 82); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(6, buffer78, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let arrayBuffer16 = buffer45.getMappedRange(152, 200); |
| try { |
| commandEncoder244.copyTextureToTexture({ |
| texture: texture121, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 3}, |
| aspect: 'depth-only', |
| }, |
| { |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline59 = device0.createComputePipeline({layout: pipelineLayout5, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| let commandEncoder245 = device0.createCommandEncoder(); |
| let textureView234 = texture87.createView({aspect: 'depth-only'}); |
| let computePassEncoder201 = commandEncoder245.beginComputePass(); |
| try { |
| computePassEncoder201.setPipeline(pipeline40); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder55.setBindGroup(3, bindGroup113, new Uint32Array(3417), 1_245, 0); |
| } catch {} |
| try { |
| renderPassEncoder59.setIndexBuffer(buffer24, 'uint32', 8_736, 4_437); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderPassEncoder68.setVertexBuffer(5, buffer120, 20, 361); |
| } catch {} |
| try { |
| buffer38.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer113, 1120, new BigUint64Array(7890), 2883); |
| } catch {} |
| let bindGroup149 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 5, resource: textureView182}, |
| {binding: 20, resource: textureView22}, |
| {binding: 18, resource: textureView201}, |
| ], |
| }); |
| let commandEncoder246 = device0.createCommandEncoder(); |
| let textureView235 = texture1.createView({}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup118); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer98, 'uint16', 730, 872); |
| } catch {} |
| try { |
| commandEncoder244.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas3); |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| alias vec3b = vec3<bool>; |
| |
| struct FragmentOutput7 { |
| @location(0) @interpolate(flat, centroid) f0: vec4i, |
| } |
| |
| struct T0 { |
| @size(88) f0: mat3x4h, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<private> vp4 = modf(f16(13192.9)); |
| |
| fn fn0() { |
| let ptr123: ptr<private, vec3f> = &vp3.fract; |
| var vf70: f16 = dot(vec2h(unconst_f16(2771.4), unconst_f16(5363.6)), vec2h(unconst_f16(2853.2), unconst_f16(9328.5))); |
| vp3.fract = unpack2x16unorm(u32(unconst_u32(265))).yyy; |
| var vf71: vec3f = tan(vec3f(unconst_f32(0.07964), unconst_f32(0.1061), unconst_f32(0.01459))); |
| vp3.fract = vec3f(vf71[u32(unconst_u32(397))]); |
| let vf72: vec3h = fma(vec3h(unconst_f16(-12377.1), unconst_f16(-2722.4), unconst_f16(25407.3)), vec3h(unconst_f16(6609.1), unconst_f16(1443.1), unconst_f16(2098.8)), vec3h(unconst_f16(1597.0), unconst_f16(1756.9), unconst_f16(3396.0))); |
| let vf73: f32 = (*ptr123)[u32(unconst_u32(412))]; |
| let ptr124: ptr<private, f16> = &vp4.whole; |
| let ptr125 = &vp3; |
| let vf74: vec3h = vf72; |
| vp3 = modf(vec3f(f32(pack4x8unorm(vec4f(unconst_f32(0.2733), unconst_f32(0.1803), unconst_f32(0.03683), unconst_f32(0.08377)))))); |
| vp4 = modf(vec3h(vp3.whole)[2]); |
| var vf75: vec4f = unpack4x8unorm(countLeadingZeros(vec4u(unconst_u32(357), unconst_u32(16), unconst_u32(409), unconst_u32(472)))[0]); |
| let ptr126: ptr<private, vec3f> = &(*ptr125).fract; |
| let vf76: vec3h = fma(vec3h(unconst_f16(1484.8), unconst_f16(546.3), unconst_f16(-6845.8)), vec3h(unconst_f16(265.5), unconst_f16(757.3), unconst_f16(15853.5)), vec3h(unconst_f16(42081.3), unconst_f16(2658.6), unconst_f16(17192.4))); |
| vp5 = modf(unpack2x16unorm(pack4x8unorm(vec4f(unconst_f32(0.2641), unconst_f32(0.1806), unconst_f32(-0.02485), unconst_f32(0.08763))))); |
| vp4.whole = vec3h((*ptr126)).x; |
| var vf77: u32 = pack4x8unorm(vec4f(unconst_f32(0.02717), unconst_f32(0.08944), unconst_f32(0.1166), unconst_f32(0.4499))); |
| vp4.whole *= vec3h(vp3.whole).y; |
| var vf78: f32 = (*ptr123)[u32(unconst_u32(11))]; |
| vp3 = modf(vec3f(vf72)); |
| let ptr127: ptr<private, vec3f> = &(*ptr123); |
| vf78 = f32((*ptr124)); |
| let vf79: u32 = dot(vec4u(unconst_u32(39), unconst_u32(123), unconst_u32(22), unconst_u32(159)), vec4u(unconst_u32(29), unconst_u32(155), unconst_u32(5), unconst_u32(479))); |
| let ptr128: ptr<private, vec3f> = &(*ptr125).fract; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw29: atomic<i32>; |
| |
| var<private> vp3 = modf(vec3f(0.3836, 0.2336, 0.1212)); |
| |
| fn fn2(a0: array<array<FragmentOutput7, 1>, 11>) { |
| var vf80: array<FragmentOutput7, 1> = a0[u32(unconst_u32(24))]; |
| vp3 = modf(bitcast<vec3f>(vf80[u32(unconst_u32(39))].f0.gab)); |
| fn1(); |
| atomicSub(&vw29, i32(unconst_i32(56))); |
| atomicAdd(&vw29, i32(unconst_i32(92))); |
| var vf81 = fn1(); |
| atomicMax(&vw29, i32(unconst_i32(345))); |
| var vf82 = fn1(); |
| fn1(); |
| fn1(); |
| vw28[u32(unconst_u32(307))] = S6(vec4u(sinh(vec4h(unconst_f16(2083.5), unconst_f16(18111.1), unconst_f16(16918.0), unconst_f16(9951.8))))[3]); |
| atomicMax(&buffer158[u32(unconst_u32(68))], u32(unconst_u32(245))); |
| vw28[u32(unconst_u32(44))] = (*&vw28)[53]; |
| atomicMin(&vw29, i32(unconst_i32(43))); |
| vf81[u32(unconst_u32(78))] += mat2x2f(bitcast<f32>(atomicLoad(&buffer158[u32(unconst_u32(49))])), f32(atomicLoad(&buffer158[u32(unconst_u32(49))])), f32(atomicLoad(&buffer158[u32(unconst_u32(49))])), bitcast<f32>(atomicLoad(&buffer158[u32(unconst_u32(49))]))); |
| vp3.fract = vec3f(f32(vw28[53].f0)); |
| fn0(); |
| let ptr129: ptr<function, vec4i> = &vf80[0].f0; |
| vp5.whole *= bitcast<vec2f>(a0[10][0].f0.yy); |
| var vf83: FragmentOutput7 = a0[u32(unconst_u32(30))][0]; |
| var vf84: vec4i = a0[10][0].f0; |
| fn1(); |
| _ = buffer158; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct S6 { |
| @builtin(sample_index) f0: u32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(32) var<storage, read_write> buffer158: array<atomic<u32>, 21>; |
| |
| var<private> vp5 = modf(vec2f(-0.06465, 0.2954)); |
| |
| struct VertexOutput4 { |
| @invariant @builtin(position) f8: vec4f, |
| } |
| |
| var<workgroup> vw28: array<S6, 54>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn fn1() -> array<mat2x2f, 1> { |
| var out: array<mat2x2f, 1>; |
| fn0(); |
| fn0(); |
| return out; |
| } |
| |
| @vertex |
| fn vertex5(@location(4) @interpolate(linear) a0: f32, @location(10) @interpolate(flat, sample) a1: vec2f, @location(7) @interpolate(flat) a2: vec2u, @location(14) @interpolate(flat, center) a3: vec2h) -> VertexOutput4 { |
| var out: VertexOutput4; |
| var vf85: f16 = a3[u32(unconst_u32(21))]; |
| vp5 = modf(vec2f(f32(a3[u32(unconst_u32(38))]))); |
| fn0(); |
| vp4 = modf(f16(a1[1])); |
| var vf86: vec3f = tan(vec3f(unconst_f32(0.07086), unconst_f32(0.05359), unconst_f32(0.3532))); |
| return out; |
| } |
| |
| @fragment |
| fn fragment7(a0: S6) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| var vf87 = fn1(); |
| let ptr130 = &vp4; |
| let vf88: f16 = atanh(f16(unconst_f16(20.39))); |
| vp3.whole *= vec3f(sqrt(vec3h(unconst_f16(7371.0), unconst_f16(1329.8), unconst_f16(3163.4)))); |
| vp4 = modf(vp4.fract); |
| vp4.fract *= trunc(vec2h(unconst_f16(12208.0), unconst_f16(6791.5))).x; |
| vp5.whole *= vec2f(vf87[u32(unconst_u32(175))][u32(unconst_u32(14))][u32(unconst_u32(73))]); |
| fn0(); |
| fn0(); |
| let vf89: vec2i = sign(vec2i(unconst_i32(277), unconst_i32(33))); |
| fn0(); |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 2, 2) |
| fn compute8() { |
| fn2(array<array<FragmentOutput7, 1>, 11>(array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32(vp4.fract)))))); |
| vp4.whole *= f16(atomicLoad(&(*&buffer158)[u32(unconst_u32(54))])); |
| fn1(); |
| fn0(); |
| let ptr131: ptr<workgroup, S6> = &(*&vw28)[53]; |
| let vf90: u32 = pack2x16float(vec2f(unconst_f32(0.2934), unconst_f32(0.1256))); |
| let ptr132: ptr<workgroup, S6> = &vw28[u32(unconst_u32(48))]; |
| fn2(array<array<FragmentOutput7, 1>, 11>(array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(bitcast<i32>((*&vw28)[u32(unconst_u32(419))].f0)))), array<FragmentOutput7, 1>(FragmentOutput7(vec4i(i32((*&vw28)[u32(unconst_u32(419))].f0)))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))), array<FragmentOutput7, 1>(FragmentOutput7(unpack4xI8((*&vw28)[u32(unconst_u32(419))].f0))))); |
| let ptr133: ptr<workgroup, u32> = &(*&vw28)[53].f0; |
| fn1(); |
| let vf91: u32 = vf90; |
| vw28[u32(unconst_u32(53))] = S6((*ptr132).f0); |
| vp4.fract = f16((*ptr131).f0); |
| var vf92 = fn1(); |
| vp5.fract = vec2f(faceForward(bitcast<vec2h>(vw28[u32(unconst_u32(82))].f0), vec2h(unconst_f16(1820.6), unconst_f16(-16148.1)), vec2h(unconst_f16(4733.6), unconst_f16(2666.0)))); |
| let vf93: u32 = atomicLoad(&(*&buffer158)[20]); |
| vf92[u32(unconst_u32(35))] += mat2x2f(step(f32(unconst_f32(0.3809)), f32(unconst_f32(0.3053))), step(f32(unconst_f32(0.3809)), f32(unconst_f32(0.3053))), step(f32(unconst_f32(0.3809)), f32(unconst_f32(0.3053))), step(f32(unconst_f32(0.3809)), f32(unconst_f32(0.3053)))); |
| vp3 = modf(vp3.fract); |
| _ = buffer158; |
| }`, |
| }); |
| let buffer159 = device0.createBuffer({ |
| size: 5449, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder247 = device0.createCommandEncoder({}); |
| let renderPassEncoder72 = commandEncoder247.beginRenderPass({ |
| colorAttachments: [{view: textureView218, depthSlice: 101, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet15, |
| maxDrawCount: 20965493, |
| }); |
| let sampler170 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 62.66, |
| lodMaxClamp: 77.35, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder140.setBindGroup(0, bindGroup37, []); |
| } catch {} |
| try { |
| commandEncoder246.copyBufferToBuffer(buffer129, 3524, buffer88, 5640, 688); |
| } catch {} |
| let commandEncoder248 = device0.createCommandEncoder({}); |
| let texture246 = device0.createTexture({ |
| size: [30, 10, 4], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView236 = texture4.createView({aspect: 'depth-only', format: 'depth32float', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderPassEncoder73 = commandEncoder244.beginRenderPass({ |
| colorAttachments: [{view: textureView221, loadOp: 'load', storeOp: 'store'}], |
| occlusionQuerySet: querySet4, |
| }); |
| try { |
| renderPassEncoder34.setBindGroup(3, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder69.setIndexBuffer(buffer88, 'uint32', 772, 2_430); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(5, buffer87, 552, 212); |
| } catch {} |
| let textureView237 = texture194.createView({aspect: 'depth-only', arrayLayerCount: 1}); |
| let computePassEncoder202 = commandEncoder248.beginComputePass({}); |
| try { |
| computePassEncoder64.setPipeline(pipeline46); |
| } catch {} |
| try { |
| renderPassEncoder44.executeBundles([renderBundle17]); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer130, 'uint16', 422, 185); |
| } catch {} |
| let arrayBuffer17 = buffer75.getMappedRange(168, 72); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture247 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder203 = commandEncoder246.beginComputePass({}); |
| try { |
| renderPassEncoder50.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer80, 'uint32', 2_624, 1_413); |
| } catch {} |
| let pipeline60 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| let offscreenCanvas7 = new OffscreenCanvas(70, 77); |
| let bindGroup150 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout74, |
| entries: [{binding: 8, resource: {buffer: buffer28, offset: 768}}], |
| }); |
| let commandEncoder249 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder202.setPipeline(pipeline48); |
| } catch {} |
| try { |
| renderPassEncoder40.setScissorRect(30, 19, 8, 1); |
| } catch {} |
| let arrayBuffer18 = buffer111.getMappedRange(184, 2104); |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer145, 776, new Float32Array(3710), 484, 104); |
| } catch {} |
| try { |
| if (!arrayBuffer15.detached) { new Uint8Array(arrayBuffer15).fill(0x55); }; |
| } catch {} |
| let texture248 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView238 = texture135.createView({aspect: 'all', format: 'rgba8sint', mipLevelCount: 1, baseArrayLayer: 0}); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder122.setBindGroup(0, bindGroup82, new Uint32Array(1414), 277, 0); |
| } catch {} |
| try { |
| computePassEncoder203.setPipeline(pipeline9); |
| } catch {} |
| try { |
| buffer153.unmap(); |
| } catch {} |
| let gpuCanvasContext11 = offscreenCanvas7.getContext('webgpu'); |
| let textureView239 = texture102.createView({}); |
| let computePassEncoder204 = commandEncoder249.beginComputePass({}); |
| try { |
| computePassEncoder139.setBindGroup(1, bindGroup115); |
| } catch {} |
| try { |
| computePassEncoder122.setBindGroup(2, bindGroup115, new Uint32Array(368), 67, 0); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(1, buffer39, 0, 28); |
| } catch {} |
| let commandEncoder250 = device0.createCommandEncoder({}); |
| let texture249 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder205 = commandEncoder250.beginComputePass({}); |
| try { |
| renderPassEncoder38.setBindGroup(2, bindGroup12, new Uint32Array(470), 138, 0); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer28, 'uint32', 1_672, 1_104); |
| } catch {} |
| let img5 = await imageWithData(71, 16, '#10101010', '#20202020'); |
| let imageBitmap9 = await createImageBitmap(videoFrame16); |
| let commandEncoder251 = device0.createCommandEncoder(); |
| let textureView240 = texture249.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 1}); |
| let computePassEncoder206 = commandEncoder251.beginComputePass({}); |
| let renderBundle30 = renderBundleEncoder30.finish({}); |
| let sampler171 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 88.91}); |
| try { |
| computePassEncoder68.setBindGroup(0, bindGroup67, new Uint32Array(331), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder206.setPipeline(pipeline42); |
| } catch {} |
| try { |
| renderPassEncoder56.beginOcclusionQuery(3); |
| } catch {} |
| try { |
| renderPassEncoder56.endOcclusionQuery(); |
| } catch {} |
| let img6 = await imageWithData(11, 7, '#10101010', '#20202020'); |
| try { |
| externalTexture23.label = '\u0749\u{1fbab}\u2b0a\u27d1\u08db\u7b58\u0eac\u{1fa9c}\u{1fe9c}'; |
| } catch {} |
| let recycledExplicitBindGroupLayout19 = pipeline5.getBindGroupLayout(0); |
| let bindGroup151 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer15, offset: 19200, size: 8480}}], |
| }); |
| let buffer160 = device0.createBuffer({size: 4045, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder68); computePassEncoder68.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder68); computePassEncoder68.dispatchWorkgroupsIndirect(buffer140, 1_092); }; |
| } catch {} |
| try { |
| computePassEncoder204.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup126, new Uint32Array(148), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer53, 'uint16', 7_874, 90); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(0, buffer70); |
| } catch {} |
| try { |
| computePassEncoder145.pushDebugGroup('\u0701'); |
| } catch {} |
| let veryExplicitBindGroupLayout32 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder252 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder51.setBindGroup(2, bindGroup92); |
| } catch {} |
| try { |
| renderPassEncoder71.setBindGroup(0, bindGroup118, new Uint32Array(28), 2, 0); |
| } catch {} |
| try { |
| commandEncoder252.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 400 */ |
| offset: 400, |
| rowsPerImage: 2411, |
| buffer: buffer27, |
| }, { |
| texture: texture249, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData14, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 19, y: 20, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture32.label = '\u3a5c\u01e3\u0800'; |
| } catch {} |
| let commandEncoder253 = device0.createCommandEncoder({}); |
| let renderPassEncoder74 = commandEncoder252.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView221, |
| clearValue: { r: -511.1, g: 952.8, b: 551.3, a: -186.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler172 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 60.84, |
| lodMaxClamp: 98.97, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder68); computePassEncoder68.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| commandEncoder253.copyBufferToBuffer(buffer89, 104, buffer112, 156, 112); |
| } catch {} |
| let textureView241 = texture220.createView({}); |
| let computePassEncoder207 = commandEncoder253.beginComputePass({}); |
| try { |
| computePassEncoder174.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder205.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let recycledExplicitBindGroupLayout20 = pipeline21.getBindGroupLayout(1); |
| let buffer161 = device0.createBuffer({ |
| size: 18977, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView242 = texture117.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder70.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup53, new Uint32Array(114), 75, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setScissorRect(28, 36, 11, 2); |
| } catch {} |
| let bindGroup152 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout88, |
| entries: [{binding: 8, resource: {buffer: buffer145, offset: 2560}}], |
| }); |
| let texture250 = device0.createTexture({ |
| size: {width: 60}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView243 = texture61.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6}); |
| let sampler173 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 79.91, lodMaxClamp: 96.54}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder68); computePassEncoder68.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder47.setIndexBuffer(buffer94, 'uint32', 220, 16); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| document.body.append(img1); |
| let veryExplicitBindGroupLayout33 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 43, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 216, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let textureView244 = texture53.createView({aspect: 'all'}); |
| try { |
| computePassEncoder126.setBindGroup(1, bindGroup45, new Uint32Array(481), 31, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(3, buffer145, 0, 553); |
| } catch {} |
| let canvas5 = document.createElement('canvas'); |
| let bindGroup153 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout62, |
| entries: [{binding: 8, resource: {buffer: buffer137, offset: 3072, size: 144}}], |
| }); |
| let commandEncoder254 = device0.createCommandEncoder({}); |
| let texture251 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 147}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder208 = commandEncoder254.beginComputePass({}); |
| try { |
| computePassEncoder75.setBindGroup(2, bindGroup64, new Uint32Array(1174), 316, 0); |
| } catch {} |
| try { |
| computePassEncoder68.end(); |
| } catch {} |
| try { |
| renderPassEncoder68.setBindGroup(0, bindGroup143); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToTexture({ |
| /* bytesInLastRow: 144 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3360 */ |
| offset: 3360, |
| bytesPerRow: 33280, |
| buffer: buffer156, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 7, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 36, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder55.insertDebugMarker('\u88f1'); |
| } catch {} |
| let commandBuffer18 = commandEncoder80.finish(); |
| try { |
| computePassEncoder160.setBindGroup(1, bindGroup151, new Uint32Array(556), 23, 0); |
| } catch {} |
| try { |
| computePassEncoder207.setPipeline(pipeline21); |
| } catch {} |
| try { |
| computePassEncoder145.popDebugGroup(); |
| } catch {} |
| try { |
| computePassEncoder116.insertDebugMarker('\u07bd'); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer18]); |
| } catch {} |
| let pipeline61 = device0.createComputePipeline({layout: pipelineLayout4, compute: {module: shaderModule2, constants: {override4: 0}}}); |
| let buffer162 = device0.createBuffer({ |
| size: 3795, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView245 = texture228.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let textureView246 = texture248.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder186.setBindGroup(0, bindGroup20, new Uint32Array(3548), 237, 0); |
| } catch {} |
| try { |
| computePassEncoder208.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup153, new Uint32Array(337), 93, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setViewport(3.1540063997037926, 18.275376882850395, 29.594964740249768, 1.7233750903226968, 0.514629271494298, 0.779055612738637); |
| } catch {} |
| let texture252 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder126.setBindGroup(3, bindGroup119); |
| } catch {} |
| try { |
| computePassEncoder90.setBindGroup(2, bindGroup43, new Uint32Array(3770), 371, 0); |
| } catch {} |
| try { |
| renderPassEncoder66.setBindGroup(1, bindGroup100); |
| } catch {} |
| try { |
| buffer152.unmap(); |
| } catch {} |
| let commandEncoder255 = device0.createCommandEncoder(); |
| let texture253 = device0.createTexture({ |
| size: [240, 80, 61], |
| sampleCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder75 = commandEncoder255.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView221, |
| clearValue: { r: -341.2, g: 298.3, b: 338.4, a: 241.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler174 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 12, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer110, 4976, new BigUint64Array(17217), 3207, 276); |
| } catch {} |
| let bindGroup154 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout45, |
| entries: [{binding: 8, resource: {buffer: buffer19, offset: 1280}}], |
| }); |
| let querySet34 = device0.createQuerySet({type: 'occlusion', count: 1261}); |
| let externalTexture36 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| renderPassEncoder58.setIndexBuffer(buffer162, 'uint32', 884, 81); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline26); |
| } catch {} |
| await gc(); |
| try { |
| canvas5.getContext('webgl'); |
| } catch {} |
| let autogeneratedBindGroupLayout92 = pipeline3.getBindGroupLayout(0); |
| let bindGroup155 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout65, |
| entries: [{binding: 8, resource: {buffer: buffer162, offset: 0, size: 532}}], |
| }); |
| let textureView247 = texture248.createView({mipLevelCount: 1}); |
| let renderBundleEncoder31 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgba8sint'], |
| depthStencilFormat: 'depth32float', |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let sampler175 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| lodMinClamp: 70.55, |
| lodMaxClamp: 87.59, |
| }); |
| try { |
| computePassEncoder38.setBindGroup(3, bindGroup131); |
| } catch {} |
| try { |
| computePassEncoder191.setBindGroup(2, bindGroup46, new Uint32Array(2522), 338, 0); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| document.body.append(canvas4); |
| let veryExplicitBindGroupLayout34 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 104, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true }, |
| }, |
| { |
| binding: 643, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture254 = device0.createTexture({ |
| size: {width: 30}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder89.setBindGroup(0, bindGroup131); |
| } catch {} |
| try { |
| renderPassEncoder53.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder43.setBlendConstant({ r: 937.4, g: -936.7, b: -428.4, a: -942.3, }); |
| } catch {} |
| try { |
| renderBundleEncoder31.setBindGroup(1, bindGroup140); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(6, buffer153); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer84, 1388, new DataView(new ArrayBuffer(9344)), 3926, 1500); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let veryExplicitBindGroupLayout35 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let recycledExplicitBindGroupLayout21 = pipeline46.getBindGroupLayout(0); |
| let commandEncoder256 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder186.setBindGroup(0, bindGroup93); |
| } catch {} |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup148, new Uint32Array(2378), 418, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(3, bindGroup55); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle18, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer46, 0, 684); |
| } catch {} |
| try { |
| renderBundleEncoder31.setBindGroup(1, bindGroup129, new Uint32Array(4511), 742, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 1040, new BigUint64Array(7070), 811, 1688); |
| } catch {} |
| document.body.append(img4); |
| let texture255 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder209 = commandEncoder256.beginComputePass(); |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer94, 'uint16', 10, 257); |
| } catch {} |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer146, 'uint32', 940, 20); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(0, buffer160, 1_148); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let bindGroup156 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout33, |
| entries: [{binding: 43, resource: textureView110}, {binding: 216, resource: externalTexture24}], |
| }); |
| let commandEncoder257 = device0.createCommandEncoder({}); |
| let querySet35 = device0.createQuerySet({type: 'occlusion', count: 501}); |
| let renderBundle31 = renderBundleEncoder31.finish({}); |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup89, new Uint32Array(1121), 234, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle31, renderBundle16, renderBundle20, renderBundle9, renderBundle2, renderBundle20, renderBundle5, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder56.setVertexBuffer(6, buffer34, 2_752, 1_214); |
| } catch {} |
| try { |
| await buffer141.mapAsync(GPUMapMode.READ); |
| } catch {} |
| document.body.append(canvas0); |
| let recycledAutogeneratedBindGroupLayout5 = pipeline30.getBindGroupLayout(0); |
| let buffer163 = device0.createBuffer({ |
| size: 2309, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture256 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView248 = texture221.createView({dimension: '2d-array', format: 'rgba8sint', baseMipLevel: 0}); |
| let computePassEncoder210 = commandEncoder257.beginComputePass(); |
| try { |
| computePassEncoder209.setPipeline(pipeline35); |
| } catch {} |
| let autogeneratedBindGroupLayout93 = pipeline14.getBindGroupLayout(0); |
| let bindGroup157 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout80, |
| entries: [{binding: 8, resource: {buffer: buffer125, offset: 0, size: 3120}}], |
| }); |
| try { |
| computePassEncoder116.setBindGroup(1, bindGroup93); |
| } catch {} |
| try { |
| computePassEncoder210.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup98, new Uint32Array(1610), 315, 0); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer94, 'uint16', 76, 58); |
| } catch {} |
| document.body.prepend(img6); |
| let recycledExplicitBindGroupLayout22 = pipeline59.getBindGroupLayout(0); |
| try { |
| renderPassEncoder63.setPipeline(pipeline51); |
| } catch {} |
| try { |
| renderPassEncoder71.insertDebugMarker('\u{1ff86}'); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData39, |
| origin: { x: 0, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 20, y: 65, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer164 = device0.createBuffer({ |
| size: 5539, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup94); |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(0, bindGroup50, new Uint32Array(1966), 36, 0); |
| } catch {} |
| let arrayBuffer19 = buffer65.getMappedRange(1232, 16); |
| document.body.append(img5); |
| let commandEncoder258 = device0.createCommandEncoder({label: '\u4871\u{1fb5c}\u2152\uc395\u199c'}); |
| let computePassEncoder211 = commandEncoder258.beginComputePass({}); |
| try { |
| computePassEncoder187.setBindGroup(2, bindGroup121); |
| } catch {} |
| try { |
| computePassEncoder211.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(6, buffer123, 440); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer84, 732, new BigUint64Array(170), 11, 4); |
| } catch {} |
| let pipeline62 = device0.createComputePipeline({ |
| layout: pipelineLayout10, |
| compute: {module: shaderModule6, entryPoint: 'compute7', constants: {46_193: 0, override12: 0}}, |
| }); |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let buffer165 = device0.createBuffer({ |
| size: 16568, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder259 = device0.createCommandEncoder(); |
| let computePassEncoder212 = commandEncoder259.beginComputePass({}); |
| try { |
| renderPassEncoder60.executeBundles([renderBundle17, renderBundle21, renderBundle22]); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); }; |
| } catch {} |
| let recycledExplicitBindGroupLayout23 = pipeline52.getBindGroupLayout(0); |
| let bindGroup158 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout45, |
| entries: [{binding: 8, resource: {buffer: buffer129, offset: 3072}}], |
| }); |
| let buffer166 = device0.createBuffer({ |
| size: 1444, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture257 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView249 = texture4.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1}); |
| try { |
| computePassEncoder212.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, buffer15, 13_980); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| document.body.prepend(canvas3); |
| let bindGroup159 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout75, |
| entries: [{binding: 8, resource: {buffer: buffer23, offset: 768, size: 848}}], |
| }); |
| let commandEncoder260 = device0.createCommandEncoder({}); |
| let textureView250 = texture227.createView({}); |
| let computePassEncoder213 = commandEncoder260.beginComputePass({}); |
| try { |
| computePassEncoder213.setPipeline(pipeline62); |
| } catch {} |
| let videoFrame37 = new VideoFrame(videoFrame16, {timestamp: 0}); |
| let texture258 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 294}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder49.beginOcclusionQuery(139); |
| } catch {} |
| try { |
| renderPassEncoder49.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer28, 'uint16', 506, 138); |
| } catch {} |
| try { |
| computePassEncoder64.insertDebugMarker('\u{1fabf}'); |
| } catch {} |
| try { |
| renderPassEncoder30.insertDebugMarker('\uabb1'); |
| } catch {} |
| let pipeline63 = await device0.createRenderPipelineAsync({ |
| label: '\ud9db\u2588\u0f89\u4713\u0e8d\u0d3e\u0c1d\uc046\u030a\u{1f65f}', |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment6', |
| constants: {override12: 0}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}], |
| }, |
| vertex: {module: shaderModule0, buffers: []}, |
| primitive: {topology: 'line-list', cullMode: 'front'}, |
| }); |
| let autogeneratedBindGroupLayout94 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder261 = device0.createCommandEncoder({}); |
| let texture259 = device0.createTexture({size: [240, 80, 62], format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder214 = commandEncoder261.beginComputePass({}); |
| let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let sampler176 = device0.createSampler({addressModeU: 'repeat'}); |
| try { |
| computePassEncoder214.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup138, []); |
| } catch {} |
| try { |
| renderPassEncoder68.setIndexBuffer(buffer123, 'uint16', 70, 1_203); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(3, bindGroup123, []); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(1, bindGroup127, new Uint32Array(532), 26, 0); |
| } catch {} |
| try { |
| renderBundleEncoder32.setPipeline(pipeline63); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer135, 15324, new Float32Array(1671), 202, 224); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(146).fill(164), /* required buffer size: 146 */ |
| {offset: 146, bytesPerRow: 91}, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData40 = new ImageData(4, 72); |
| try { |
| adapter0.label = '\u0012\u26e1\u{1faa6}\u006b\u{1f6d1}'; |
| } catch {} |
| let textureView251 = texture22.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5}); |
| try { |
| computePassEncoder149.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup88, new Uint32Array(1510), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer164, 'uint32', 1_304, 464); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(2, bindGroup52); |
| } catch {} |
| let sampler177 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 39.94, |
| compare: 'not-equal', |
| maxAnisotropy: 14, |
| }); |
| try { |
| renderPassEncoder32.setBindGroup(1, bindGroup159, []); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup131, new Uint32Array(2628), 1_319, 0); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(1, bindGroup149, new Uint32Array(5113), 357, 0); |
| } catch {} |
| try { |
| buffer134.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let commandEncoder262 = device0.createCommandEncoder({}); |
| let texture260 = device0.createTexture({ |
| size: [120, 40, 179], |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder76 = commandEncoder262.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView218, |
| depthSlice: 201, |
| clearValue: { r: 962.5, g: 164.2, b: -55.56, a: -685.5, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder51.setVertexBuffer(6, buffer69, 172, 9); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer112, 'uint16', 360, 867); |
| } catch {} |
| try { |
| computePassEncoder191.insertDebugMarker('\u1f41'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(81).fill(36), /* required buffer size: 81 */ |
| {offset: 81, bytesPerRow: 31}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let texture261 = device0.createTexture({ |
| size: [240, 80, 28], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler178 = device0.createSampler({compare: 'not-equal', maxAnisotropy: 1}); |
| try { |
| computePassEncoder199.setBindGroup(1, bindGroup86, new Uint32Array(580), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup133); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer137, 'uint32', 3_104, 4_741); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(1, bindGroup112, new Uint32Array(2370), 8, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer94, 'uint16', 2, 131); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let buffer167 = device0.createBuffer({ |
| size: 6094, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundle32 = renderBundleEncoder32.finish({}); |
| let sampler179 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| lodMaxClamp: 92.66, |
| compare: 'less', |
| }); |
| let externalTexture37 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder50.setBindGroup(1, bindGroup57); |
| } catch {} |
| try { |
| renderPassEncoder66.setBindGroup(3, bindGroup54, new Uint32Array(5981), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer89, 'uint16', 284, 86); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer46, 0, 805); |
| } catch {} |
| try { |
| renderBundleEncoder33.setVertexBuffer(1, buffer82, 1_004); |
| } catch {} |
| let buffer168 = device0.createBuffer({ |
| size: 2295, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder97.setBindGroup(0, bindGroup146); |
| } catch {} |
| try { |
| computePassEncoder144.setBindGroup(0, bindGroup5, new Uint32Array(255), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder64.setIndexBuffer(buffer168, 'uint32', 28, 384); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder33.setVertexBuffer(6, buffer112); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer30, 828, new BigUint64Array(9208), 2962, 48); |
| } catch {} |
| let recycledExplicitBindGroupLayout24 = pipeline15.getBindGroupLayout(0); |
| let texture262 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder68.setIndexBuffer(buffer82, 'uint16', 194, 220); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer107, 'uint16', 122, 51); |
| } catch {} |
| let arrayBuffer20 = buffer111.getMappedRange(2512, 72); |
| let pipelineLayout18 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout21]}); |
| let externalTexture38 = device0.importExternalTexture({source: videoFrame18}); |
| try { |
| computePassEncoder143.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder58.executeBundles([renderBundle5, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder27.setViewport(175.57896649810348, 50.827040524040505, 41.69992417942854, 4.610636438455123, 0.4087010392003627, 0.9707786587397965); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(3, buffer26, 24, 1_449); |
| } catch {} |
| try { |
| computePassEncoder160.insertDebugMarker('\u0cd5'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture156, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(237).fill(155), /* required buffer size: 237 */ |
| {offset: 237, bytesPerRow: 22}, {width: 4, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); }; |
| } catch {} |
| let commandEncoder263 = device0.createCommandEncoder({}); |
| let textureView252 = texture27.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder215 = commandEncoder263.beginComputePass({}); |
| try { |
| computePassEncoder124.setBindGroup(3, bindGroup138); |
| } catch {} |
| try { |
| renderPassEncoder62.setStencilReference(1026); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 52, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout95 = pipeline14.getBindGroupLayout(0); |
| let textureView253 = texture215.createView({format: 'rg32sint'}); |
| try { |
| computePassEncoder215.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderPassEncoder60.setBlendConstant({ r: 897.3, g: -34.76, b: -572.0, a: 584.2, }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer160, 524, new DataView(new ArrayBuffer(19795)), 5250, 196); |
| } catch {} |
| try { |
| adapter0.label = '\u0796\uc497\u5d69\ucd93\u2dc8'; |
| } catch {} |
| let commandEncoder264 = device0.createCommandEncoder(); |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup82, new Uint32Array(1760), 556, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture204, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(6).fill(10), /* required buffer size: 6 */ |
| {offset: 6, bytesPerRow: 106}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer169 = device0.createBuffer({size: 20363, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let computePassEncoder216 = commandEncoder264.beginComputePass({}); |
| try { |
| computePassEncoder199.setBindGroup(1, bindGroup108, []); |
| } catch {} |
| try { |
| computePassEncoder216.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(2, bindGroup133); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup112, new Uint32Array(1179), 115, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(2, bindGroup43, new Uint32Array(630), 21, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setVertexBuffer(0, buffer8, 0, 488); |
| } catch {} |
| try { |
| renderPassEncoder57.pushDebugGroup('\u006c'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas3); |
| let commandEncoder265 = device0.createCommandEncoder(); |
| let computePassEncoder217 = commandEncoder265.beginComputePass(); |
| let renderBundle33 = renderBundleEncoder33.finish({}); |
| try { |
| renderPassEncoder68.setBindGroup(0, bindGroup142, new Uint32Array(509), 225, 0); |
| } catch {} |
| try { |
| renderPassEncoder45.setIndexBuffer(buffer166, 'uint32', 0, 101); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); }; |
| } catch {} |
| document.body.prepend(img6); |
| let recycledExplicitBindGroupLayout25 = pipeline41.getBindGroupLayout(0); |
| let buffer170 = device0.createBuffer({ |
| size: 3052, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder105.setBindGroup(3, bindGroup15, new Uint32Array(3550), 1_227, 0); |
| } catch {} |
| try { |
| computePassEncoder217.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderPassEncoder52.setStencilReference(12); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder109.setBindGroup(1, bindGroup74); |
| } catch {} |
| try { |
| computePassEncoder105.setBindGroup(0, bindGroup142, new Uint32Array(5422), 1_131, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder105); computePassEncoder105.dispatchWorkgroupsIndirect(buffer38, 2_236); }; |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(1, bindGroup99, new Uint32Array(3703), 345, 0); |
| } catch {} |
| let buffer171 = device0.createBuffer({ |
| size: 3763, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let textureView254 = texture26.createView({baseArrayLayer: 3, arrayLayerCount: 1}); |
| try { |
| computePassEncoder87.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 192, y: 10, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(165).fill(110), /* required buffer size: 165 */ |
| {offset: 165, bytesPerRow: 134}, {width: 33, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder266 = device0.createCommandEncoder({}); |
| let computePassEncoder218 = commandEncoder266.beginComputePass(); |
| try { |
| computePassEncoder82.setBindGroup(2, bindGroup80, new Uint32Array(988), 288, 0); |
| } catch {} |
| try { |
| computePassEncoder218.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder53.executeBundles([renderBundle2, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer119, 'uint32', 1_288, 756); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline24); |
| } catch {} |
| try { |
| computePassEncoder26.pushDebugGroup('\u{1f8e3}'); |
| } catch {} |
| let img7 = await imageWithData(31, 51, '#10101010', '#20202020'); |
| let texture263 = device0.createTexture({ |
| size: [240, 80, 294], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder34 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint']}); |
| try { |
| renderPassEncoder70.setIndexBuffer(buffer168, 'uint32', 252, 141); |
| } catch {} |
| try { |
| renderBundleEncoder34.setBindGroup(3, bindGroup49, new Uint32Array(2888), 1_196, 0); |
| } catch {} |
| try { |
| renderBundleEncoder34.setIndexBuffer(buffer29, 'uint16', 98, 6_027); |
| } catch {} |
| let buffer172 = device0.createBuffer({ |
| size: 8018, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let textureView255 = texture124.createView({dimension: '2d', baseMipLevel: 0}); |
| let renderBundle34 = renderBundleEncoder34.finish(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder105); computePassEncoder105.dispatchWorkgroupsIndirect(buffer125, 2_588); }; |
| } catch {} |
| try { |
| renderPassEncoder50.setBindGroup(2, bindGroup57, new Uint32Array(479), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline3); |
| } catch {} |
| let buffer173 = device0.createBuffer({ |
| size: 11144, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder267 = device0.createCommandEncoder({}); |
| let texture264 = device0.createTexture({ |
| label: '\u3ab0\ubc33\u2c46\u6538\u0aff', |
| size: {width: 30, height: 10, depthOrArrayLayers: 26}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder219 = commandEncoder267.beginComputePass({}); |
| try { |
| computePassEncoder219.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup30, new Uint32Array(4456), 2_539, 0); |
| } catch {} |
| try { |
| renderPassEncoder48.setIndexBuffer(buffer113, 'uint32', 4_464, 6_166); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline44); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(1, buffer129, 0); |
| } catch {} |
| let recycledExplicitBindGroupLayout26 = pipeline63.getBindGroupLayout(0); |
| let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1, stencilReadOnly: false}); |
| let sampler180 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'mirror-repeat', lodMinClamp: 32.56, lodMaxClamp: 95.80}); |
| try { |
| computePassEncoder73.setBindGroup(3, bindGroup97, new Uint32Array(70), 12, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder105); computePassEncoder105.dispatchWorkgroupsIndirect(buffer166, 28); }; |
| } catch {} |
| try { |
| renderPassEncoder64.setBindGroup(2, bindGroup69, new Uint32Array(1135), 13, 0); |
| } catch {} |
| try { |
| buffer75.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let buffer174 = device0.createBuffer({size: 1903, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let textureView256 = texture215.createView({aspect: 'all', baseArrayLayer: 0}); |
| let renderBundle35 = renderBundleEncoder35.finish({}); |
| try { |
| computePassEncoder170.setBindGroup(1, bindGroup92); |
| } catch {} |
| try { |
| computePassEncoder51.setBindGroup(2, bindGroup64, new Uint32Array(802), 55, 0); |
| } catch {} |
| let commandEncoder268 = device0.createCommandEncoder({}); |
| let texture265 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler181 = device0.createSampler({addressModeU: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 75.45}); |
| try { |
| renderPassEncoder74.setVertexBuffer(5, buffer15); |
| } catch {} |
| document.body.prepend(img4); |
| let buffer175 = device0.createBuffer({ |
| size: 19178, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView257 = texture232.createView({}); |
| let renderPassEncoder77 = commandEncoder268.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 17, |
| clearValue: { r: -351.7, g: -631.0, b: -927.3, a: -214.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView169, depthReadOnly: true, stencilReadOnly: true}, |
| }); |
| let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup85, new Uint32Array(1112), 40, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder105); computePassEncoder105.dispatchWorkgroupsIndirect(buffer50, 108); }; |
| } catch {} |
| try { |
| computePassEncoder105.end(); |
| } catch {} |
| try { |
| renderPassEncoder74.setIndexBuffer(buffer113, 'uint16', 7_738, 5_878); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline44); |
| } catch {} |
| try { |
| renderPassEncoder52.setVertexBuffer(1, undefined, 0, 626_681_415); |
| } catch {} |
| try { |
| renderBundleEncoder36.setBindGroup(1, bindGroup119, new Uint32Array(6660), 401, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout96 = pipeline19.getBindGroupLayout(0); |
| let bindGroup160 = device0.createBindGroup({ |
| label: '\ue442\u9571\u078b\u{1f71a}\ue440\u4bd3\u06d6\u69d3\u68a1\u37d5', |
| layout: autogeneratedBindGroupLayout92, |
| entries: [{binding: 8, resource: {buffer: buffer154, offset: 1024}}], |
| }); |
| let pipelineLayout19 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout32]}); |
| try { |
| computePassEncoder176.setBindGroup(0, bindGroup115, new Uint32Array(492), 57, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup125); |
| } catch {} |
| try { |
| renderPassEncoder73.setIndexBuffer(buffer40, 'uint32', 4_756, 10_549); |
| } catch {} |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer171, 'uint16', 492, 128); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 11, y: 17 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 488, y: 35, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let imageData41 = new ImageData(168, 44); |
| let bindGroup161 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout21, |
| entries: [{binding: 8, resource: {buffer: buffer66, offset: 256, size: 552}}], |
| }); |
| let computePassEncoder220 = commandEncoder122.beginComputePass({}); |
| let renderBundle36 = renderBundleEncoder36.finish({}); |
| let externalTexture39 = device0.importExternalTexture({source: videoFrame24}); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup140); |
| } catch {} |
| try { |
| computePassEncoder220.setPipeline(pipeline25); |
| } catch {} |
| let promise28 = shaderModule5.getCompilationInfo(); |
| let bindGroup162 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout31, |
| entries: [ |
| {binding: 216, resource: textureView92}, |
| {binding: 8, resource: {buffer: buffer98, offset: 768, size: 700}}, |
| ], |
| }); |
| let textureView258 = texture260.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 22}); |
| try { |
| renderPassEncoder9.beginOcclusionQuery(130); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| let bindGroup163 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout50, |
| entries: [{binding: 8, resource: {buffer: buffer83, offset: 1280, size: 148}}], |
| }); |
| let texture266 = device0.createTexture({ |
| size: [2, 2, 13], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer114, 'uint32', 100, 59); |
| } catch {} |
| try { |
| renderPassEncoder57.popDebugGroup(); |
| } catch {} |
| await gc(); |
| let bindGroup164 = device0.createBindGroup({ |
| label: '\u{1fb05}\u080f\uc865', |
| layout: autogeneratedBindGroupLayout72, |
| entries: [{binding: 8, resource: {buffer: buffer107, offset: 0, size: 100}}], |
| }); |
| let textureView259 = texture136.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder62.setBindGroup(2, bindGroup95); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 388, new Float32Array(6353), 48, 192); |
| } catch {} |
| let pipeline64 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule7, targets: [{format: 'rg32sint'}]}, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 880, |
| attributes: [ |
| {format: 'snorm16x2', offset: 44, shaderLocation: 14}, |
| {format: 'snorm16x2', offset: 244, shaderLocation: 11}, |
| {format: 'snorm8x2', offset: 20, shaderLocation: 2}, |
| {format: 'float32x3', offset: 8, shaderLocation: 13}, |
| {format: 'snorm8x2', offset: 430, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 212, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm8x2', offset: 142, shaderLocation: 0}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', unclippedDepth: false}, |
| }); |
| try { |
| await promise28; |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 605, y: 7, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline65 = await device0.createComputePipelineAsync({layout: pipelineLayout18, compute: {module: shaderModule4, entryPoint: 'compute4'}}); |
| let texture267 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder183.setBindGroup(1, bindGroup62); |
| } catch {} |
| try { |
| computePassEncoder83.setBindGroup(2, bindGroup91, new Uint32Array(3235), 171, 0); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder31.executeBundles([renderBundle28]); |
| } catch {} |
| try { |
| renderPassEncoder75.setVertexBuffer(0, buffer80, 0, 65); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let buffer176 = device0.createBuffer({ |
| size: 7462, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder269 = device0.createCommandEncoder({}); |
| let sampler182 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 85.80}); |
| try { |
| computePassEncoder136.setBindGroup(1, bindGroup52); |
| } catch {} |
| try { |
| computePassEncoder187.setBindGroup(2, bindGroup97, new Uint32Array(785), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder57.setIndexBuffer(buffer98, 'uint16', 618, 218); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline27); |
| } catch {} |
| try { |
| commandEncoder269.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 168 */ |
| offset: 168, |
| bytesPerRow: 9472, |
| buffer: buffer87, |
| }, { |
| texture: texture104, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder269.resolveQuerySet(querySet11, 351, 74, buffer74, 256); |
| } catch {} |
| try { |
| computePassEncoder26.popDebugGroup(); |
| } catch {} |
| let autogeneratedBindGroupLayout97 = pipeline22.getBindGroupLayout(0); |
| let buffer177 = device0.createBuffer({size: 1319, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder270 = device0.createCommandEncoder({}); |
| let texture268 = device0.createTexture({ |
| size: [60, 20, 1], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView260 = texture79.createView({aspect: 'all'}); |
| let computePassEncoder221 = commandEncoder269.beginComputePass({}); |
| try { |
| computePassEncoder221.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(2, bindGroup122, new Uint32Array(3552), 919, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.end(); |
| } catch {} |
| try { |
| renderPassEncoder39.setScissorRect(35, 2, 62, 21); |
| } catch {} |
| try { |
| commandEncoder270.clearBuffer(buffer13, 628, 6216); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let imageData42 = new ImageData(68, 80); |
| let querySet36 = device0.createQuerySet({type: 'occlusion', count: 778}); |
| let commandBuffer19 = commandEncoder121.finish(); |
| let texture269 = device0.createTexture({ |
| size: [2, 2, 163], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder222 = commandEncoder270.beginComputePass({}); |
| try { |
| computePassEncoder70.setBindGroup(2, bindGroup57, []); |
| } catch {} |
| try { |
| computePassEncoder164.setBindGroup(3, bindGroup130, new Uint32Array(1341), 542, 0); |
| } catch {} |
| try { |
| computePassEncoder222.setPipeline(pipeline59); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(3, bindGroup109); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(1, buffer78, 2_112, 177); |
| } catch {} |
| try { |
| buffer27.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let veryExplicitBindGroupLayout36 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup165 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout64, |
| entries: [{binding: 8, resource: {buffer: buffer8, offset: 1024, size: 720}}], |
| }); |
| let buffer178 = device0.createBuffer({ |
| size: 1378, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture270 = device0.createTexture({ |
| size: [60, 20, 8], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer171, 'uint16', 20, 1_324); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(7, buffer77, 0); |
| } catch {} |
| let pipeline66 = device0.createComputePipeline({ |
| layout: pipelineLayout18, |
| compute: {module: shaderModule6, entryPoint: 'compute7', constants: {46_193: 0, override12: 0}}, |
| }); |
| document.body.prepend(img5); |
| let videoFrame38 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteRp431', transfer: 'smpte240m'} }); |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| var<workgroup> vw36: atomic<u32>; |
| |
| var<workgroup> vw31: array<array<array<FragmentOutput9, 1>, 1>, 2>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw35: vec2<bool>; |
| |
| struct T0 { |
| @size(8) f0: array<u32>, |
| } |
| |
| fn fn0() -> array<vec2i, 17> { |
| var out: array<vec2i, 17>; |
| var vf94: f16 = (*&vw30)[1].f9[u32(unconst_u32(130))]; |
| let ptr134: ptr<workgroup, vec2u> = &(*&vw33).f11; |
| let ptr135: ptr<workgroup, vec4i> = &vw31[1][0][u32(unconst_u32(0))].f0; |
| return out; |
| } |
| |
| var<workgroup> vw33: VertexOutput5; |
| |
| var<workgroup> vw34: FragmentOutput8; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn fn1() -> array<vec4i, 1> { |
| var out: array<vec4i, 1>; |
| let vf95: u32 = pack4xI8Clamp(vec4i(unconst_i32(146), unconst_i32(148), unconst_i32(143), unconst_i32(168))); |
| out[u32(unconst_u32(235))] = vec4i(i32(exp2(f32(unconst_f32(0.05419))))); |
| vp6 &= vec2u(vf95); |
| out[u32(unconst_u32(121))] -= unpack4xI8(vp6[u32(unconst_u32(670))]); |
| let vf96: u32 = pack4xI8Clamp(vec4i(i32(dot(vec4h(unconst_f16(17595.5), unconst_f16(1073.7), unconst_f16(16602.2), unconst_f16(4352.6)), vec4h(unconst_f16(35406.2), unconst_f16(24742.2), unconst_f16(3544.2), unconst_f16(1384.8)))))); |
| vp6 ^= vec2u(insertBits(vec3i(unconst_i32(116), unconst_i32(469), unconst_i32(127)), vec3i(unconst_i32(97), unconst_i32(82), unconst_i32(260)), u32(unconst_u32(33)), u32(unconst_u32(8))).zx); |
| let vf97: vec2f = unpack2x16unorm(u32(unconst_u32(27))); |
| let vf98: vec2f = unpack2x16unorm(u32(unconst_u32(231))); |
| var vf99: vec4h = refract(vec4h(unconst_f16(22489.4), unconst_f16(6376.4), unconst_f16(12910.1), unconst_f16(2763.6)), vec4h(unconst_f16(2267.6), unconst_f16(563.7), unconst_f16(4403.4), unconst_f16(16347.9)), f16(unconst_f16(14466.0))); |
| var vf100: vec3f = sinh(vec3f(unconst_f32(0.4962), unconst_f32(0.03385), unconst_f32(0.2184))); |
| var vf101: u32 = pack4xI8Clamp(vec4i(unconst_i32(26), unconst_i32(33), unconst_i32(87), unconst_i32(180))); |
| return out; |
| } |
| |
| struct VertexOutput5 { |
| @location(13) @interpolate(perspective, center) f9: vec4h, |
| @location(15) f10: i32, |
| @location(12) @interpolate(flat, centroid) f11: vec2u, |
| @builtin(position) f12: vec4f, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp6: vec2u = vec2u(21, 0); |
| |
| struct FragmentOutput8 { |
| @builtin(sample_mask) f0: u32, |
| @location(0) f1: vec4i, |
| } |
| |
| var<workgroup> vw32: f32; |
| |
| var<workgroup> vw30: array<VertexOutput5, 2>; |
| |
| struct FragmentOutput9 { |
| @location(0) @interpolate(flat) f0: vec4i, |
| } |
| |
| @vertex |
| fn vertex6(@location(14) a0: vec2i, @location(0) a1: vec2i) -> VertexOutput5 { |
| var out: VertexOutput5; |
| out.f12 -= vec4f(f32(all(bool(unconst_bool(false))))); |
| var vf102: u32 = pack2x16snorm(vec2f(unconst_f32(0.00177), unconst_f32(0.07436))); |
| vf102 <<= bitcast<u32>(max(i32(unconst_i32(53)), i32(unconst_i32(7)))); |
| out.f12 -= bitcast<vec4f>(firstTrailingBit(vec3i(a1[u32(unconst_u32(60))])).yyxx); |
| out.f9 = vec4h(f16(all(bool(unconst_bool(true))))); |
| vp6 ^= vec2u(u32(asinh(f32(unconst_f32(0.1087))))); |
| return out; |
| } |
| |
| @fragment |
| fn fragment8() -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| out = FragmentOutput8(pack4x8unorm(unpack4x8unorm(u32(unconst_u32(32)))), bitcast<vec4i>(unpack4x8unorm(u32(unconst_u32(32))))); |
| out.f1 = unpack4xI8(pack2x16unorm(vec2f(unconst_f32(0.08222), unconst_f32(0.02175)))); |
| out.f1 |= bitcast<vec4i>(vp6.yxyx); |
| return out; |
| } |
| |
| @fragment |
| fn fragment9() -> FragmentOutput9 { |
| var out: FragmentOutput9; |
| var vf103: vec2f = unpack2x16snorm(u32(unconst_u32(92))); |
| vp6 += bitcast<vec2u>(unpack2x16snorm(u32(unconst_u32(47)))); |
| out.f0 |= vec4i(bitcast<i32>(vp6[vp6.x])); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute9() { |
| fn0(); |
| vw33 = vw30[u32(unconst_u32(184))]; |
| vw31[u32(unconst_u32(45))][u32(unconst_u32(62))][u32(unconst_u32(333))] = vw31[u32(vw30[1].f10)][0][u32(unconst_u32(72))]; |
| let ptr136: ptr<workgroup, array<FragmentOutput9, 1>> = &(*&vw31)[u32(unconst_u32(1))][0]; |
| fn0(); |
| atomicCompareExchangeWeak(&vw36, unconst_u32(93), unconst_u32(48)); |
| fn1(); |
| let ptr137: ptr<workgroup, vec4f> = &vw33.f12; |
| let vf104: i32 = (*ptr136)[0].f0[u32(unconst_u32(33))]; |
| var vf105 = fn1(); |
| vw34.f1 = bitcast<vec4i>(vw30[u32(unconst_u32(1))].f11.gggg); |
| fn0(); |
| vw32 = bitcast<f32>((*&vw34).f0); |
| var vf106 = fn0(); |
| fn0(); |
| var vf107 = fn1(); |
| vf105[u32(unconst_u32(345))] = vw31[u32(unconst_u32(118))][0][bitcast<vec4u>(vw31[pack4xI8Clamp(vf107[0])][0][0].f0).y].f0; |
| vf106[16] = vec2i((*&vw30)[1].f11); |
| vw32 += vec4f((*&vw31)[u32(unconst_u32(209))][u32(unconst_u32(156))][u32(unconst_u32(69))].f0)[3]; |
| vf105[u32(unconst_u32(111))] = vec4i((*&vw33).f9); |
| let ptr138: ptr<workgroup, i32> = &(*&vw33).f10; |
| var vf108 = fn1(); |
| fn0(); |
| }`, |
| }); |
| let texture271 = device0.createTexture({ |
| size: [30, 10, 30], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder65.setBindGroup(2, bindGroup58, new Uint32Array(3039), 1_076, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer29, 'uint32', 280, 911); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(0, buffer137); |
| } catch {} |
| let arrayBuffer21 = buffer111.getMappedRange(2288, 60); |
| let buffer180 = device0.createBuffer({size: 10077, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture272 = device0.createTexture({ |
| size: [1, 1, 1], |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView261 = texture69.createView({aspect: 'depth-only', mipLevelCount: 1, arrayLayerCount: 2}); |
| try { |
| computePassEncoder161.setBindGroup(1, bindGroup125); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup89); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData41, |
| origin: { x: 30, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 73, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 36, height: 29, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder271 = device0.createCommandEncoder({}); |
| let textureView262 = texture272.createView({label: '\u607c\u02c0\u7d20'}); |
| try { |
| computePassEncoder158.setBindGroup(0, bindGroup163, new Uint32Array(846), 94, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle12, renderBundle6, renderBundle20, renderBundle4, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder45.setIndexBuffer(buffer94, 'uint16', 0, 162); |
| } catch {} |
| try { |
| renderPassEncoder73.setPipeline(pipeline63); |
| } catch {} |
| let bindGroup166 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout63, |
| entries: [{binding: 8, resource: {buffer: buffer41, offset: 3840, size: 3832}}], |
| }); |
| let pipelineLayout20 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout38]}); |
| let buffer181 = device0.createBuffer({ |
| size: 19570, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture273 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView263 = texture131.createView({}); |
| let computePassEncoder223 = commandEncoder271.beginComputePass({}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup147, new Uint32Array(4100), 219, 0); |
| } catch {} |
| try { |
| computePassEncoder223.setPipeline(pipeline42); |
| } catch {} |
| try { |
| renderPassEncoder54.setBlendConstant({ r: 217.3, g: 528.8, b: -247.9, a: -110.2, }); |
| } catch {} |
| document.body.prepend(img5); |
| let bindGroup167 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout94, |
| entries: [{binding: 8, resource: {buffer: buffer17, offset: 256}}], |
| }); |
| let buffer182 = device0.createBuffer({ |
| size: 2718, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder272 = device0.createCommandEncoder({}); |
| let computePassEncoder224 = commandEncoder272.beginComputePass({}); |
| let sampler183 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 79.66, |
| lodMaxClamp: 92.58, |
| }); |
| try { |
| computePassEncoder150.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(1, buffer29, 1_712, 2_892); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture162, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(203).fill(93), /* required buffer size: 203 */ |
| {offset: 203, bytesPerRow: 84}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); }; |
| } catch {} |
| document.body.append(img3); |
| let bindGroup168 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout63, |
| entries: [{binding: 8, resource: {buffer: buffer163, offset: 0, size: 480}}], |
| }); |
| let commandEncoder273 = device0.createCommandEncoder(); |
| let textureView264 = texture254.createView({baseMipLevel: 0, baseArrayLayer: 0}); |
| let renderPassEncoder78 = commandEncoder273.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView218, |
| depthSlice: 138, |
| clearValue: { r: -468.6, g: 166.4, b: -835.3, a: -6.976, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder166.setBindGroup(3, bindGroup163); |
| } catch {} |
| try { |
| computePassEncoder224.setPipeline(pipeline45); |
| } catch {} |
| try { |
| renderPassEncoder38.setStencilReference(927); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer101, 'uint32', 884, 836); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| document.body.prepend(img4); |
| let querySet37 = device0.createQuerySet({type: 'occlusion', count: 43}); |
| let sampler184 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder104.setBindGroup(2, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(3, bindGroup83); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup97, new Uint32Array(2320), 732, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u966b'); |
| } catch {} |
| let autogeneratedBindGroupLayout98 = pipeline13.getBindGroupLayout(0); |
| let texture274 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 43}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler185 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 22.52, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder140.setBindGroup(0, bindGroup91); |
| } catch {} |
| try { |
| computePassEncoder27.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline33); |
| } catch {} |
| let bindGroup169 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [{binding: 8, resource: {buffer: buffer140, offset: 768, size: 912}}], |
| }); |
| let textureView265 = texture243.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6}); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer19]); |
| } catch {} |
| let autogeneratedBindGroupLayout99 = pipeline10.getBindGroupLayout(0); |
| let bindGroup170 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout30, |
| entries: [{binding: 105, resource: textureView6}, {binding: 343, resource: textureView170}], |
| }); |
| let textureView266 = texture45.createView({dimension: '2d-array'}); |
| let texture275 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView267 = texture224.createView({label: '\u{1fd63}\u0e46\u64f0\u00a0\uf663\u064c\u158e\u0419\u{1f8bd}\u{1fa58}', mipLevelCount: 1}); |
| let computePassEncoder225 = commandEncoder32.beginComputePass({}); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup142, new Uint32Array(2789), 35, 0); |
| } catch {} |
| try { |
| computePassEncoder225.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder48.setScissorRect(10, 52, 157, 4); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer166, 'uint16', 28, 658); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let bindGroup171 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 8, resource: {buffer: buffer22, offset: 5120, size: 3244}}], |
| }); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup114); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder75.setVertexBuffer(3, buffer26); |
| } catch {} |
| let arrayBuffer22 = buffer65.getMappedRange(1248, 40); |
| let shaderModule9 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| struct T0 { |
| f0: atomic<u32>, |
| @size(52) f1: atomic<u32>, |
| } |
| |
| struct VertexOutput6 { |
| @invariant @builtin(position) f13: vec4f, |
| } |
| |
| var<workgroup> vw38: atomic<i32>; |
| |
| @id(1422) override override25: bool; |
| |
| struct FragmentOutput11 { |
| @location(0) f0: vec4i, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(8) var<storage, read> buffer183: array<array<array<array<f16, 1>, 3>, 1>, 9>; |
| |
| override override28: u32; |
| |
| var<workgroup> vw37: array<atomic<u32>, 1>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @id(10930) override override30: f16 = 10539.9; |
| |
| @id(60915) override override27: u32; |
| |
| var<workgroup> vw39: vec2f; |
| |
| @id(21664) override override26 = true; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| override override29: f16; |
| |
| struct FragmentOutput10 { |
| @location(0) f0: vec4i, |
| } |
| |
| var<workgroup> vw40: FragmentOutput11; |
| |
| var<private> vp7: vec2u = vec2u(424, 47); |
| |
| override override31: f32; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| @vertex @must_use |
| fn vertex7() -> VertexOutput6 { |
| var out: VertexOutput6; |
| out.f13 = vec4f(f32((*&buffer183)[8][0][2][0])); |
| let ptr139: ptr<storage, f16, read> = &buffer183[u32(unconst_u32(21))][0][u32(unconst_u32(168))][0]; |
| let ptr140: ptr<storage, array<f16, 1>, read> = &(*&buffer183)[8][0][u32(buffer183[u32(buffer183[8][u32(unconst_u32(433))][u32(unconst_u32(90))][0])][0][2][0])]; |
| let ptr141: ptr<storage, f16, read> = &buffer183[8][0][u32(unconst_u32(101))][0]; |
| out = VertexOutput6(vec4f(f32((*&buffer183)[8][0][2][0]))); |
| vp7 = vec2u(u32(buffer183[8][0][2][0])); |
| var vf109: u32 = firstTrailingBit(u32(unconst_u32(67))); |
| out.f13 += vec4f(f32(buffer183[u32((*&buffer183)[8][0][u32(unconst_u32(72))][0])][0][2][u32(unconst_u32(134))])); |
| let ptr142: ptr<storage, f16, read> = &(*&buffer183)[u32(unconst_u32(48))][0][u32(unconst_u32(85))][u32(unconst_u32(266))]; |
| let ptr143: ptr<storage, array<f16, 1>, read> = &(*&buffer183)[8][0][u32(unconst_u32(49))]; |
| out.f13 = vec4f(f32(buffer183[8][0][2][0])); |
| vp7 |= vec2u(u32((*&buffer183)[u32(unconst_u32(71))][u32(unconst_u32(55))][2][0])); |
| out.f13 = vec4f(extractBits(vec2i(unconst_i32(214), unconst_i32(18)), u32(unconst_u32(101)), u32(unconst_u32(83))).grrr); |
| let ptr144: ptr<storage, f16, read> = &buffer183[u32(unconst_u32(62))][u32(buffer183[8][u32(unconst_u32(686))][2][0])][2][0]; |
| let ptr145: ptr<storage, f16, read> = &(*&buffer183)[8][0][2][u32(unconst_u32(199))]; |
| let ptr146: ptr<storage, f16, read> = &(*&buffer183)[u32(unconst_u32(112))][u32(unconst_u32(196))][2][u32(unconst_u32(23))]; |
| var vf110: vec4f = reflect(vec4f(unconst_f32(0.6183), unconst_f32(0.00657), unconst_f32(0.4377), unconst_f32(0.00951)), vec4f(unconst_f32(0.02018), unconst_f32(0.2574), unconst_f32(0.1338), unconst_f32(0.07367))); |
| out.f13 += vec4f(f32(buffer183[8][0][2][0])); |
| let ptr147: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer183)[8][0]; |
| let vf111: bool = any(bool(unconst_bool(true))); |
| out.f13 = vec4f(f32((*ptr147)[2][u32(unconst_u32(134))])); |
| vf110 = vec4f(f32(buffer183[8][u32(unconst_u32(650))][u32(unconst_u32(105))][0])); |
| out.f13 = vec4f(f32(buffer183[8][u32(unconst_u32(377))][2][0])); |
| let ptr148: ptr<storage, array<f16, 1>, read> = &buffer183[8][u32(unconst_u32(572))][2]; |
| return out; |
| _ = buffer183; |
| } |
| |
| @fragment |
| fn fragment10() -> FragmentOutput10 { |
| var out: FragmentOutput10; |
| let ptr149: ptr<storage, array<array<array<array<f16, 1>, 3>, 1>, 9>, read> = &buffer183; |
| discard; |
| let ptr150: ptr<storage, array<f16, 1>, read> = &(*&buffer183)[u32((*ptr149)[8][u32(unconst_u32(52))][u32(unconst_u32(593))][0])][0][u32(unconst_u32(87))]; |
| let ptr151: ptr<storage, f16, read> = &(*ptr149)[8][u32(unconst_u32(160))][u32(unconst_u32(78))][u32(unconst_u32(315))]; |
| let ptr152: ptr<storage, array<f16, 1>, read> = &buffer183[8][0][2]; |
| out.f0 -= bitcast<vec4i>(reflect(vec3f(unconst_f32(0.00256), unconst_f32(0.03072), unconst_f32(0.08572)), vec3f(unconst_f32(0.03313), unconst_f32(0.3255), unconst_f32(0.1037))).yxyz); |
| out.f0 += vec4i(floor(vec4f(unconst_f32(0.1955), unconst_f32(0.9360), unconst_f32(0.08490), unconst_f32(0.3724)))); |
| let ptr153: ptr<storage, f16, read> = &(*ptr149)[u32(unconst_u32(208))][u32(unconst_u32(189))][2][u32(unconst_u32(42))]; |
| let ptr154: ptr<storage, f16, read> = &(*ptr149)[u32(unconst_u32(8))][u32(unconst_u32(67))][u32(unconst_u32(141))][0]; |
| vp7 += vec2u(u32((*&buffer183)[8][0][2][0])); |
| vp7 = vec2u(u32((*&buffer183)[u32(unconst_u32(151))][u32(unconst_u32(74))][2][0])); |
| let vf112: vec2h = log2(vec2h(unpack4xI8(u32(unconst_u32(65))).yx)); |
| out.f0 = vec4i(countTrailingZeros(i32(unconst_i32(228)))); |
| let ptr155: ptr<storage, f16, read> = &(*&buffer183)[u32(unconst_u32(111))][0][u32(unconst_u32(263))][0]; |
| vp7 &= vec2u(u32((*ptr149)[8][0][u32(unconst_u32(220))][0])); |
| let ptr156: ptr<storage, f16, read> = &(*&buffer183)[u32(unconst_u32(212))][u32(unconst_u32(115))][u32(unconst_u32(372))][0]; |
| let ptr157: ptr<storage, array<f16, 1>, read> = &(*&buffer183)[8][0][u32(unconst_u32(17))]; |
| return out; |
| _ = buffer183; |
| } |
| |
| @fragment |
| fn fragment11() -> FragmentOutput11 { |
| var out: FragmentOutput11; |
| vp7 = vec2u(u32(buffer183[8][0][u32(buffer183[8][0][2][0])][0])); |
| out = FragmentOutput11(vec4i(i32(override30))); |
| let ptr158: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer183)[u32(unconst_u32(46))][u32(unconst_u32(1))]; |
| var vf113: vec4i = unpack4xI8(u32(unconst_u32(29))); |
| let ptr159: ptr<storage, f16, read> = &(*&buffer183)[8][u32(unconst_u32(13))][u32(unconst_u32(18))][u32(unconst_u32(98))]; |
| out.f0 = vec4i(i32(buffer183[u32(unconst_u32(216))][u32(unconst_u32(250))][2][u32(unconst_u32(11))])); |
| vp7 -= vec2u(u32(buffer183[pack2x16snorm(vec2f(f32(override30)))][0][2][0])); |
| out = FragmentOutput11(vec4i(i32(buffer183[u32(unconst_u32(458))][u32(unconst_u32(22))][u32(unconst_u32(104))][u32(unconst_u32(243))]))); |
| vp7 = vec2u(u32((*&buffer183)[8][0][u32(unconst_u32(456))][0])); |
| let ptr160: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer183)[u32(unconst_u32(13))][0]; |
| let ptr161: ptr<storage, array<array<array<f16, 1>, 3>, 1>, read> = &buffer183[u32(unconst_u32(229))]; |
| let ptr162: ptr<storage, array<f16, 1>, read> = &(*&buffer183)[8][u32(unconst_u32(202))][u32(unconst_u32(141))]; |
| vf113 += vec4i(i32(buffer183[u32(unconst_u32(328))][u32(buffer183[u32((*ptr161)[0][u32(unconst_u32(169))][u32(unconst_u32(129))])][u32(unconst_u32(0))][2][0])][2][u32(unconst_u32(34))])); |
| out.f0 += vec4i(i32(buffer183[u32(unconst_u32(86))][0][2][0])); |
| return out; |
| _ = override30; |
| _ = buffer183; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute10() { |
| let ptr163: ptr<storage, array<array<array<f16, 1>, 3>, 1>, read> = &buffer183[8]; |
| let ptr164: ptr<storage, f16, read> = &(*&buffer183)[8][0][u32(unconst_u32(40))][0]; |
| atomicAdd(&vw38, i32(unconst_i32(220))); |
| let ptr165: ptr<storage, f16, read> = &(*&buffer183)[u32(unconst_u32(33))][0][2][0]; |
| vp7 = vec2u(u32((*ptr163)[0][2][0])); |
| let ptr166: ptr<workgroup, atomic<u32>> = &vw37[u32(unconst_u32(16))]; |
| let ptr167: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer183)[u32(unconst_u32(354))][0]; |
| vw39 += vec2f(f32((*&buffer183)[u32(unconst_u32(175))][u32(unconst_u32(116))][2][u32(unconst_u32(509))])); |
| atomicAnd(&vw37[u32(unconst_u32(244))], u32(unconst_u32(104))); |
| let ptr168: ptr<storage, f16, read> = &buffer183[8][0][2][u32(unconst_u32(169))]; |
| vw39 = vec2f(f32((*&buffer183)[8][0][2][0])); |
| var vf114: u32 = atomicExchange(&vw37[u32(unconst_u32(109))], u32(unconst_u32(236))); |
| let vf115: u32 = atomicLoad(&vw37[u32((*&buffer183)[u32(unconst_u32(73))][0][u32(unconst_u32(806))][0])]); |
| let ptr169: ptr<storage, f16, read> = &buffer183[8][0][u32(unconst_u32(245))][u32(unconst_u32(264))]; |
| vw39 += vec2f(f32((*&buffer183)[8][0][2][0])); |
| vw40.f0 = vec4i(i32((*&buffer183)[u32(unconst_u32(3))][u32(unconst_u32(371))][2][0])); |
| let ptr170: ptr<storage, array<f16, 1>, read> = &(*ptr163)[u32(unconst_u32(79))][u32(unconst_u32(3))]; |
| let ptr171: ptr<storage, array<f16, 1>, read> = &(*ptr167)[u32(buffer183[8][0][2][u32(unconst_u32(306))])]; |
| let vf116: u32 = atomicExchange(&(*&vw37)[0], u32(unconst_u32(42))); |
| _ = buffer183; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute11() { |
| var vf117: f16 = override30; |
| let ptr172: ptr<storage, array<array<f16, 1>, 3>, read> = &buffer183[u32(unconst_u32(797))][0]; |
| let ptr173: ptr<storage, f16, read> = &(*&buffer183)[u32((*&buffer183)[u32(unconst_u32(201))][u32(unconst_u32(254))][bitcast<vec2u>(vw39).r][0])][0][2][0]; |
| let vf118: u32 = override27; |
| let ptr174: ptr<storage, f16, read> = &buffer183[u32(unconst_u32(60))][0][u32(unconst_u32(477))][u32((*&buffer183)[8][u32(unconst_u32(142))][u32(unconst_u32(6))][u32(unconst_u32(124))])]; |
| _ = override27; |
| _ = override30; |
| _ = buffer183; |
| }`, |
| }); |
| let commandEncoder274 = device0.createCommandEncoder({}); |
| let renderPassEncoder79 = commandEncoder274.beginRenderPass({ |
| colorAttachments: [{view: textureView218, depthSlice: 31, loadOp: 'load', storeOp: 'store'}], |
| occlusionQuerySet: querySet2, |
| maxDrawCount: 169896479, |
| }); |
| let sampler186 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 76.57, |
| maxAnisotropy: 3, |
| }); |
| try { |
| renderPassEncoder14.executeBundles([renderBundle18, renderBundle8, renderBundle2, renderBundle11]); |
| } catch {} |
| try { |
| buffer122.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let bindGroup172 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout97, |
| entries: [{binding: 8, resource: {buffer: buffer153, offset: 256, size: 376}}], |
| }); |
| let texture276 = device0.createTexture({ |
| size: [60, 20, 73], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView268 = texture20.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder133.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(2, bindGroup38, new Uint32Array(3843), 284, 0); |
| } catch {} |
| let bindGroup173 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 203, resource: {buffer: buffer43, offset: 1280, size: 644}}, |
| {binding: 33, resource: sampler32}, |
| ], |
| }); |
| let texture277 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView269 = texture72.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(1, bindGroup66, new Uint32Array(564), 18, 0); |
| } catch {} |
| canvas2.height = 2276; |
| let commandEncoder275 = device0.createCommandEncoder({}); |
| let querySet38 = device0.createQuerySet({type: 'occlusion', count: 764}); |
| let computePassEncoder226 = commandEncoder275.beginComputePass({}); |
| let sampler187 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'mirror-repeat', mipmapFilter: 'linear'}); |
| try { |
| computePassEncoder182.setBindGroup(2, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder71.setBindGroup(1, bindGroup28, new Uint32Array(5026), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder62.end(); |
| } catch {} |
| try { |
| renderPassEncoder59.setIndexBuffer(buffer107, 'uint16', 168, 170); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(352).fill(28), /* required buffer size: 352 */ |
| {offset: 352, bytesPerRow: 41, rowsPerImage: 21}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData43 = new ImageData(4, 32); |
| let bindGroup174 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout28, |
| entries: [ |
| {binding: 68, resource: {buffer: buffer94, offset: 0, size: 200}}, |
| {binding: 100, resource: textureView211}, |
| ], |
| }); |
| let buffer184 = device0.createBuffer({ |
| size: 2497, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let texture278 = device0.createTexture({ |
| size: [240, 80, 30], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8sint'], |
| }); |
| let textureView270 = texture248.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder227 = commandEncoder220.beginComputePass({}); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder226.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder75.setBindGroup(0, bindGroup153, new Uint32Array(440), 48, 0); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(1, buffer113, 3_668, 36_958); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 5, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(24).fill(62), /* required buffer size: 24 */ |
| {offset: 24}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder93.setBindGroup(0, bindGroup107); |
| } catch {} |
| try { |
| computePassEncoder227.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder72.beginOcclusionQuery(38); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer62, 'uint16', 1_212, 7_714); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 368, new Float32Array(41206), 595, 392); |
| } catch {} |
| let bindGroup175 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [{binding: 53, resource: {buffer: buffer39, offset: 3840, size: 2088}}], |
| }); |
| let buffer185 = device0.createBuffer({size: 1434, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture279 = device0.createTexture({size: [120, 40, 1], format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroupsIndirect(buffer23, 256); }; |
| } catch {} |
| try { |
| renderPassEncoder77.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup147, new Uint32Array(1455), 576, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer108, 1204, new Float32Array(15411), 1946, 16); |
| } catch {} |
| let textureView271 = texture42.createView({dimension: '2d'}); |
| let sampler188 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 87.43, |
| }); |
| try { |
| renderPassEncoder72.endOcclusionQuery(); |
| } catch {} |
| try { |
| buffer54.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(161).fill(28), /* required buffer size: 161 */ |
| {offset: 161, bytesPerRow: 117}, {width: 7, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler189 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.41, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder36.end(); |
| } catch {} |
| try { |
| computePassEncoder118.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer62, 'uint16', 3_634, 457); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(4, buffer97, 0, 565); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1008 */ |
| offset: 1008, |
| bytesPerRow: 5376, |
| buffer: buffer11, |
| }, { |
| texture: texture156, |
| mipLevel: 1, |
| origin: {x: 4, y: 5, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture145, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(64).fill(118), /* required buffer size: 64 */ |
| {offset: 64}, {width: 57, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup176 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout63, |
| entries: [{binding: 8, resource: {buffer: buffer108, offset: 1792, size: 232}}], |
| }); |
| let buffer186 = device0.createBuffer({ |
| size: 3786, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture280 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 13}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView272 = texture153.createView({baseArrayLayer: 25, arrayLayerCount: 23}); |
| let computePassEncoder228 = commandEncoder43.beginComputePass({}); |
| try { |
| computePassEncoder183.setBindGroup(0, bindGroup127); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle25]); |
| } catch {} |
| try { |
| renderPassEncoder75.setIndexBuffer(buffer99, 'uint16', 558, 99); |
| } catch {} |
| let imageData44 = new ImageData(20, 32); |
| let buffer187 = device0.createBuffer({ |
| size: 21778, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let texture281 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture282 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView273 = texture146.createView({baseArrayLayer: 0}); |
| let sampler190 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.39, |
| }); |
| try { |
| renderPassEncoder63.setBindGroup(1, bindGroup81); |
| } catch {} |
| let pipeline67 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}}); |
| try { |
| gpuCanvasContext10.unconfigure(); |
| } catch {} |
| let texture283 = device0.createTexture({ |
| size: [30, 10, 36], |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder71.setVertexBuffer(1, undefined, 0, 261_027_335); |
| } catch {} |
| let offscreenCanvas8 = new OffscreenCanvas(204, 72); |
| let recycledExplicitBindGroupLayout27 = pipeline48.getBindGroupLayout(0); |
| let textureView274 = texture86.createView({dimension: '2d-array', aspect: 'depth-only', arrayLayerCount: 1}); |
| let externalTexture40 = device0.importExternalTexture({source: videoFrame35}); |
| try { |
| renderPassEncoder38.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(2, bindGroup59, new Uint32Array(294), 37, 0); |
| } catch {} |
| try { |
| renderPassEncoder40.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder71.setVertexBuffer(2, buffer17, 0, 921); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer159, 1084, new BigUint64Array(12195), 777, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture165, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(214).fill(112), /* required buffer size: 214 */ |
| {offset: 214, bytesPerRow: 117, rowsPerImage: 25}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup177 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 8, resource: {buffer: buffer140, offset: 1024, size: 288}}], |
| }); |
| let textureView275 = texture252.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| computePassEncoder224.setBindGroup(3, bindGroup166); |
| } catch {} |
| try { |
| computePassEncoder228.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup123, new Uint32Array(230), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer145, 'uint16', 2_170, 184); |
| } catch {} |
| let gpuCanvasContext12 = offscreenCanvas8.getContext('webgpu'); |
| let buffer188 = device0.createBuffer({size: 255, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let querySet39 = device0.createQuerySet({type: 'occlusion', count: 1226}); |
| let textureView276 = texture89.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder144.setBindGroup(2, bindGroup169, new Uint32Array(1705), 127, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout100 = pipeline32.getBindGroupLayout(0); |
| let querySet40 = device0.createQuerySet({type: 'occlusion', count: 814}); |
| let textureView277 = texture118.createView({}); |
| try { |
| computePassEncoder146.setBindGroup(1, bindGroup129, []); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(30); |
| } catch {} |
| try { |
| renderPassEncoder65.setScissorRect(1, 2, 39, 2); |
| } catch {} |
| let bindGroup178 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout79, |
| entries: [ |
| {binding: 8, resource: {buffer: buffer41, offset: 2560, size: 1684}}, |
| {binding: 216, resource: textureView92}, |
| ], |
| }); |
| let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder196.setBindGroup(0, bindGroup142); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup112, []); |
| } catch {} |
| try { |
| renderPassEncoder74.setBindGroup(1, bindGroup15, new Uint32Array(1744), 126, 0); |
| } catch {} |
| try { |
| renderPassEncoder57.executeBundles([renderBundle34, renderBundle34, renderBundle17, renderBundle34, renderBundle34, renderBundle25, renderBundle27, renderBundle14]); |
| } catch {} |
| try { |
| renderPassEncoder54.setVertexBuffer(0, buffer17, 976, 332); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer77, 'uint32', 4_552, 18_323); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(2, buffer15, 6_964); |
| } catch {} |
| let promise29 = device0.queue.onSubmittedWorkDone(); |
| let imageData45 = new ImageData(80, 16); |
| try { |
| computePassEncoder155.setBindGroup(1, bindGroup119); |
| } catch {} |
| try { |
| renderPassEncoder65.setVertexBuffer(1, buffer102); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer181, 'uint16', 4_022, 231); |
| } catch {} |
| let pipeline68 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}}); |
| let textureView278 = texture45.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let texture284 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle37 = renderBundleEncoder37.finish({}); |
| try { |
| renderPassEncoder70.setVertexBuffer(5, buffer97, 0); |
| } catch {} |
| document.body.prepend(canvas4); |
| let autogeneratedBindGroupLayout101 = pipeline68.getBindGroupLayout(0); |
| let bindGroup179 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 8, resource: {buffer: buffer94, offset: 0, size: 116}}], |
| }); |
| let pipelineLayout21 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout20]}); |
| try { |
| renderPassEncoder76.setBindGroup(1, bindGroup153, new Uint32Array(1866), 648, 0); |
| } catch {} |
| let bindGroup180 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout82, |
| entries: [{binding: 8, resource: {buffer: buffer97, offset: 512, size: 552}}], |
| }); |
| let pipelineLayout22 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout1]}); |
| let buffer189 = device0.createBuffer({ |
| size: 11670, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer44, 'uint16', 156, 124); |
| } catch {} |
| try { |
| renderPassEncoder54.setPipeline(pipeline51); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView279 = texture107.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(26).fill(139), /* required buffer size: 26 */ |
| {offset: 26, rowsPerImage: 19}, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img2); |
| let imageData46 = new ImageData(52, 84); |
| try { |
| computePassEncoder130.setBindGroup(2, bindGroup156); |
| } catch {} |
| try { |
| computePassEncoder65.setBindGroup(0, bindGroup74, new Uint32Array(1317), 38, 0); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| document.body.prepend(canvas5); |
| let autogeneratedBindGroupLayout102 = pipeline60.getBindGroupLayout(0); |
| let buffer190 = device0.createBuffer({size: 4476, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder24.executeBundles([renderBundle16, renderBundle7, renderBundle1, renderBundle6]); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData33, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 9, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout23 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| try { |
| computePassEncoder156.setBindGroup(2, bindGroup59); |
| } catch {} |
| try { |
| computePassEncoder110.setBindGroup(1, bindGroup88, new Uint32Array(3591), 57, 0); |
| } catch {} |
| try { |
| renderPassEncoder74.setIndexBuffer(buffer166, 'uint16', 102, 217); |
| } catch {} |
| try { |
| renderPassEncoder49.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 8, new Float32Array(7636), 609, 144); |
| } catch {} |
| let pipeline69 = await device0.createComputePipelineAsync({layout: pipelineLayout18, compute: {module: shaderModule4, entryPoint: 'compute4'}}); |
| try { |
| adapter0.label = '\u{1fb80}\ua937\u54df\u071c\u{1fd3f}\u069a\u0952'; |
| } catch {} |
| let texture285 = device0.createTexture({ |
| size: [240, 80, 294], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture286 = device0.createTexture({ |
| size: [120], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder136.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| computePassEncoder158.setBindGroup(3, bindGroup52, new Uint32Array(917), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(0, bindGroup26, new Uint32Array(2159), 291, 0); |
| } catch {} |
| try { |
| renderPassEncoder66.setPipeline(pipeline64); |
| } catch {} |
| try { |
| buffer176.unmap(); |
| } catch {} |
| let sampler191 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 69.94, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup131); |
| } catch {} |
| try { |
| renderPassEncoder27.setViewport(11.351753209091653, 8.971783183109965, 82.26362182155314, 11.655462740265994, 0.16274497770716811, 0.6636302487036915); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(0, buffer64, 0); |
| } catch {} |
| try { |
| buffer107.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 2164, new Int16Array(22467), 3632, 1268); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture244, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(7).fill(193), /* required buffer size: 7 */ |
| {offset: 7}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise30 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData32, |
| origin: { x: 1, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 33, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 103, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout103 = pipeline26.getBindGroupLayout(0); |
| let textureView280 = texture1.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| try { |
| computePassEncoder93.setBindGroup(1, bindGroup69, new Uint32Array(2666), 631, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer85, 'uint16', 222, 77); |
| } catch {} |
| let bindGroup181 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer61, offset: 512, size: 344}}, |
| {binding: 258, resource: textureView134}, |
| ], |
| }); |
| let sampler192 = device0.createSampler({addressModeU: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 62.72}); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup148, []); |
| } catch {} |
| try { |
| computePassEncoder136.setBindGroup(2, bindGroup146, new Uint32Array(910), 236, 0); |
| } catch {} |
| try { |
| renderPassEncoder58.setBindGroup(2, bindGroup91); |
| } catch {} |
| try { |
| renderPassEncoder42.executeBundles([renderBundle20, renderBundle16, renderBundle8, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer125, 'uint16', 784, 3_084); |
| } catch {} |
| try { |
| adapter0.label = '\u{1ff4f}\ub076\u{1fdb4}\ud316\ub9e2'; |
| } catch {} |
| let texture287 = device0.createTexture({ |
| size: [2, 2, 13], |
| sampleCount: 1, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView281 = texture135.createView({format: 'rgba8sint', mipLevelCount: 1}); |
| try { |
| computePassEncoder113.setBindGroup(2, bindGroup171); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup123); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(2, buffer79, 16, 151); |
| } catch {} |
| try { |
| computePassEncoder146.setBindGroup(2, bindGroup71, new Uint32Array(1264), 306, 0); |
| } catch {} |
| try { |
| buffer84.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer166, 'uint32', 228, 325); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture169, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(95).fill(228), /* required buffer size: 95 */ |
| {offset: 95, bytesPerRow: 0}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer191 = device0.createBuffer({ |
| size: 7738, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder66.setBindGroup(0, bindGroup113); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline23); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture258, |
| mipLevel: 0, |
| origin: {x: 13, y: 28, z: 95}, |
| aspect: 'all', |
| }, new Uint8Array(691_644).fill(180), /* required buffer size: 691_644 */ |
| {offset: 57, bytesPerRow: 537, rowsPerImage: 33}, {width: 117, height: 1, depthOrArrayLayers: 40}); |
| } catch {} |
| let veryExplicitBindGroupLayout37 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 33, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 100, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 256, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 291, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 352, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup182 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout87, |
| entries: [ |
| {binding: 8, resource: {buffer: buffer178, offset: 0, size: 296}}, |
| {binding: 216, resource: textureView24}, |
| ], |
| }); |
| let textureView282 = texture189.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6}); |
| let externalTexture41 = device0.importExternalTexture({source: videoFrame15}); |
| try { |
| computePassEncoder109.setBindGroup(0, bindGroup54, []); |
| } catch {} |
| let texture288 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder67.setBindGroup(1, bindGroup179, new Uint32Array(2313), 44, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(430); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder38.setStencilReference(33); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture164, |
| mipLevel: 1, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(8_181).fill(193), /* required buffer size: 8_181 */ |
| {offset: 61, bytesPerRow: 116, rowsPerImage: 70}, {width: 6, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap9, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 461, y: 19, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout28 = pipeline25.getBindGroupLayout(0); |
| try { |
| renderPassEncoder58.setBindGroup(1, bindGroup85, new Uint32Array(2358), 412, 0); |
| } catch {} |
| try { |
| renderPassEncoder55.setVertexBuffer(0, buffer33, 76); |
| } catch {} |
| let arrayBuffer23 = buffer65.getMappedRange(1288, 0); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap8, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 29, y: 19, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder87.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| await promise29; |
| } catch {} |
| let texture289 = device0.createTexture({ |
| size: [120, 40, 147], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView283 = texture37.createView({}); |
| try { |
| computePassEncoder175.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder70.setScissorRect(42, 6, 21, 16); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 0, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 111, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas9 = new OffscreenCanvas(66, 46); |
| let veryExplicitBindGroupLayout38 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 105, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 343, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let texture290 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler193 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.03, |
| maxAnisotropy: 19, |
| }); |
| let gpuCanvasContext13 = offscreenCanvas9.getContext('webgpu'); |
| let textureView284 = texture132.createView({aspect: 'all'}); |
| let externalTexture42 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder70.setPipeline(pipeline56); |
| } catch {} |
| try { |
| renderPassEncoder42.executeBundles([renderBundle5, renderBundle20, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder50.setVertexBuffer(7, buffer17, 1_264, 1_181); |
| } catch {} |
| let arrayBuffer24 = buffer45.getMappedRange(456, 160); |
| try { |
| device0.queue.writeBuffer(buffer132, 1304, new Float32Array(7478), 156, 324); |
| } catch {} |
| try { |
| await promise30; |
| } catch {} |
| let recycledExplicitBindGroupLayout29 = pipeline62.getBindGroupLayout(0); |
| let renderBundleEncoder38 = device0.createRenderBundleEncoder({colorFormats: ['rg32sint'], stencilReadOnly: true}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture117, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(94).fill(55), /* required buffer size: 94 */ |
| {offset: 94, bytesPerRow: 131}, {width: 24, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer192 = device0.createBuffer({ |
| size: 10337, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder154.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| computePassEncoder116.setBindGroup(1, bindGroup45, new Uint32Array(5780), 4_855, 0); |
| } catch {} |
| try { |
| renderPassEncoder78.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer147, 'uint32', 1_088, 959); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(3, buffer33); |
| } catch {} |
| try { |
| renderBundleEncoder38.setBindGroup(1, bindGroup40, new Uint32Array(1364), 120, 0); |
| } catch {} |
| let arrayBuffer25 = buffer111.getMappedRange(2352, 24); |
| let pipeline70 = await device0.createComputePipelineAsync({ |
| layout: pipelineLayout21, |
| compute: {module: shaderModule9, entryPoint: 'compute11', constants: {60_915: 0}}, |
| }); |
| let autogeneratedBindGroupLayout104 = pipeline26.getBindGroupLayout(0); |
| let texture291 = device0.createTexture({size: [120, 40, 51], mipLevelCount: 2, format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let renderBundle38 = renderBundleEncoder38.finish({}); |
| let sampler194 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 92.52}); |
| try { |
| buffer151.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture134, |
| mipLevel: 0, |
| origin: {x: 5, y: 5, z: 39}, |
| aspect: 'all', |
| }, new Uint8Array(23_953).fill(80), /* required buffer size: 23_953 */ |
| {offset: 173, bytesPerRow: 26, rowsPerImage: 101}, {width: 4, height: 6, depthOrArrayLayers: 10}); |
| } catch {} |
| let buffer193 = device0.createBuffer({size: 13898, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView285 = texture150.createView({dimension: '2d', baseArrayLayer: 1}); |
| try { |
| computePassEncoder109.setBindGroup(0, bindGroup81); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(0, bindGroup139); |
| } catch {} |
| try { |
| renderPassEncoder67.setBindGroup(0, bindGroup99, new Uint32Array(5471), 1_047, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([]); |
| } catch {} |
| try { |
| renderPassEncoder39.setScissorRect(43, 22, 11, 29); |
| } catch {} |
| try { |
| renderPassEncoder65.setVertexBuffer(7, buffer151, 188, 577); |
| } catch {} |
| await gc(); |
| let veryExplicitBindGroupLayout39 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 32, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let textureView286 = texture287.createView({dimension: '2d'}); |
| let textureView287 = texture177.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| try { |
| computePassEncoder86.setBindGroup(0, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup95); |
| } catch {} |
| try { |
| buffer141.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame17, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 273, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer194 = device0.createBuffer({ |
| size: 20481, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| }); |
| let textureView288 = texture3.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer107, 'uint16', 238, 11); |
| } catch {} |
| try { |
| renderPassEncoder66.setVertexBuffer(2, buffer59); |
| } catch {} |
| let bindGroup183 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout84, |
| entries: [{binding: 8, resource: {buffer: buffer39, offset: 0, size: 2152}}], |
| }); |
| let buffer195 = device0.createBuffer({ |
| size: 7535, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let textureView289 = texture11.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder187.setBindGroup(0, bindGroup108, new Uint32Array(3), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder79.setIndexBuffer(buffer109, 'uint16', 22, 54); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture221, |
| mipLevel: 0, |
| origin: {x: 12, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(25).fill(232), /* required buffer size: 25 */ |
| {offset: 25, rowsPerImage: 6}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout30 = pipeline52.getBindGroupLayout(0); |
| let texture292 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder140.setBindGroup(2, bindGroup177, new Uint32Array(93), 3, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let texture293 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder59.setBindGroup(1, bindGroup20, new Uint32Array(250), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer109, 'uint32', 0, 12); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba16float'], |
| }); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); }; |
| } catch {} |
| let textureView290 = texture223.createView({baseArrayLayer: 0}); |
| let sampler195 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'nearest'}); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup11, new Uint32Array(1674), 800, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer171, 'uint32', 444, 377); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer181, 0, 6_000); |
| } catch {} |
| try { |
| computePassEncoder47.pushDebugGroup('\uf636'); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(1, bindGroup123); |
| } catch {} |
| try { |
| buffer83.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer85, 1260, new Int16Array(4747), 258, 276); |
| } catch {} |
| let bindGroup184 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout13, |
| entries: [{binding: 8, resource: {buffer: buffer115, offset: 768, size: 2436}}], |
| }); |
| let bindGroup185 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [{binding: 396, resource: {buffer: buffer84, offset: 512, size: 268}}], |
| }); |
| let texture294 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 294}, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: false, stencilReadOnly: false}); |
| let sampler196 = device0.createSampler({addressModeW: 'repeat', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 86.20}); |
| try { |
| renderPassEncoder75.setIndexBuffer(buffer36, 'uint16', 394, 678); |
| } catch {} |
| try { |
| renderPassEncoder54.setVertexBuffer(4, buffer59); |
| } catch {} |
| try { |
| renderBundleEncoder39.setIndexBuffer(buffer153, 'uint32', 272, 273); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| computePassEncoder47.popDebugGroup(); |
| } catch {} |
| let querySet41 = device0.createQuerySet({type: 'occlusion', count: 319}); |
| let sampler197 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.73, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder192.setBindGroup(3, bindGroup118); |
| } catch {} |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup111, new Uint32Array(481), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder64.setBindGroup(2, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder21.setScissorRect(59, 23, 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer105, 'uint32', 1_172, 704); |
| } catch {} |
| try { |
| computePassEncoder106.setBindGroup(3, bindGroup92, new Uint32Array(161), 31, 0); |
| } catch {} |
| try { |
| renderBundleEncoder39.setBindGroup(3, bindGroup145, new Uint32Array(434), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.insertDebugMarker('\u0b1d'); |
| } catch {} |
| let videoFrame39 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'film', transfer: 'logSqrt'} }); |
| let buffer196 = device0.createBuffer({size: 2481, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture295 = device0.createTexture({size: {width: 60}, dimension: '1d', format: 'rgba8sint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView291 = texture98.createView({mipLevelCount: 1, baseArrayLayer: 66}); |
| let renderBundle39 = renderBundleEncoder39.finish({}); |
| let sampler198 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'linear'}); |
| try { |
| computePassEncoder214.setBindGroup(0, bindGroup66, new Uint32Array(990), 204, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setVertexBuffer(7, buffer159); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture296 = device0.createTexture({ |
| size: {width: 1, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder30.setPipeline(pipeline44); |
| } catch {} |
| try { |
| buffer87.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame22, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 18, y: 20, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout31 = pipeline25.getBindGroupLayout(0); |
| let bindGroup186 = device0.createBindGroup({ |
| label: '\ua742\u1010\ubaaf\u{1f906}\uacb2', |
| layout: autogeneratedBindGroupLayout91, |
| entries: [ |
| {binding: 8, resource: {buffer: buffer61, offset: 256, size: 1424}}, |
| {binding: 216, resource: textureView24}, |
| ], |
| }); |
| let textureView292 = texture268.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder97.setBindGroup(0, bindGroup61, new Uint32Array(138), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer80, 'uint16', 1_792, 1_563); |
| } catch {} |
| let querySet42 = device0.createQuerySet({type: 'occlusion', count: 3639}); |
| let sampler199 = device0.createSampler({addressModeU: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 89.35}); |
| try { |
| computePassEncoder121.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder76.setBindGroup(2, bindGroup184, new Uint32Array(4991), 291, 0); |
| } catch {} |
| let imageData47 = new ImageData(28, 16); |
| let bindGroup187 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout57, |
| entries: [{binding: 8, resource: {buffer: buffer85, offset: 1024}}], |
| }); |
| let texture297 = device0.createTexture({ |
| size: {width: 1, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder38.setBindGroup(0, bindGroup46, new Uint32Array(1094), 275, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer173, 'uint16', 1_476, 5_932); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let recycledExplicitBindGroupLayout32 = pipeline37.getBindGroupLayout(0); |
| let bindGroup188 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout11, |
| entries: [{binding: 258, resource: textureView201}, {binding: 116, resource: {buffer: buffer85, offset: 256}}], |
| }); |
| let buffer197 = device0.createBuffer({ |
| size: 4388, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler200 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 90.15, |
| lodMaxClamp: 94.84, |
| }); |
| try { |
| renderPassEncoder32.beginOcclusionQuery(31); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(7, buffer120, 48, 132); |
| } catch {} |
| let imageData48 = new ImageData(20, 48); |
| let bindGroup189 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout75, |
| entries: [{binding: 8, resource: {buffer: buffer189, offset: 8448, size: 736}}], |
| }); |
| let sampler201 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat'}); |
| try { |
| renderPassEncoder32.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setBlendConstant({ r: -705.0, g: -662.0, b: -277.9, a: 772.4, }); |
| } catch {} |
| try { |
| renderPassEncoder52.setVertexBuffer(7, buffer132, 4_148); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| computePassEncoder44.setBindGroup(1, bindGroup38, new Uint32Array(615), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup185); |
| } catch {} |
| let veryExplicitBindGroupLayout40 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 13, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 217, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 252, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder83.setBindGroup(2, bindGroup109, new Uint32Array(1610), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(3, bindGroup165, new Uint32Array(2565), 322, 0); |
| } catch {} |
| try { |
| computePassEncoder189.pushDebugGroup('\uebb6'); |
| } catch {} |
| try { |
| computePassEncoder189.popDebugGroup(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline43); |
| } catch {} |
| let pipeline71 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment10', |
| constants: {}, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALPHA}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'equal', |
| stencilReadMask: 448305405, |
| stencilWriteMask: 504776883, |
| depthBias: -868774828, |
| depthBiasSlopeScale: 161.02611878274132, |
| depthBiasClamp: -74.25540117566453, |
| }, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 1136, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x3', offset: 572, shaderLocation: 0}, |
| {format: 'float32x4', offset: 124, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 400, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 194, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 892, shaderLocation: 2}, |
| {format: 'snorm16x2', offset: 80, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer198 = device0.createBuffer({size: 8624, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let sampler202 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 49.20, |
| maxAnisotropy: 18, |
| }); |
| try { |
| renderPassEncoder56.setIndexBuffer(buffer123, 'uint16', 1_420, 148); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| let autogeneratedBindGroupLayout105 = pipeline18.getBindGroupLayout(0); |
| let bindGroup190 = device0.createBindGroup({ |
| layout: recycledAutogeneratedBindGroupLayout3, |
| entries: [{binding: 8, resource: {buffer: buffer79, offset: 0, size: 144}}], |
| }); |
| let querySet43 = device0.createQuerySet({type: 'occlusion', count: 12}); |
| let texture298 = device0.createTexture({ |
| label: '\u04ef\ud522\u{1f8c0}\u7a15\u64d0', |
| size: [2, 2, 1], |
| sampleCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture299 = device0.createTexture({size: [120], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []}); |
| let textureView293 = texture2.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder75.setPipeline(pipeline63); |
| } catch {} |
| let textureView294 = texture125.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1}); |
| let sampler203 = device0.createSampler({addressModeV: 'repeat', minFilter: 'nearest', lodMaxClamp: 91.69}); |
| try { |
| computePassEncoder71.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder67.setViewport(140.0879461742269, 13.198894049755117, 62.861610253899876, 48.08089529457232, 0.40632234253649324, 0.4949070493290795); |
| } catch {} |
| try { |
| renderPassEncoder70.setIndexBuffer(buffer153, 'uint32', 100, 127); |
| } catch {} |
| try { |
| gpuCanvasContext13.unconfigure(); |
| } catch {} |
| let recycledAutogeneratedBindGroupLayout6 = pipeline30.getBindGroupLayout(0); |
| let bindGroup191 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout25, |
| entries: [{binding: 8, resource: {buffer: buffer49, offset: 2560}}], |
| }); |
| let buffer199 = device0.createBuffer({size: 19517, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let texture300 = device0.createTexture({size: [120, 40, 1], format: 'rgba16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder155.setBindGroup(1, bindGroup108); |
| } catch {} |
| try { |
| computePassEncoder128.end(); |
| } catch {} |
| try { |
| renderPassEncoder65.setBindGroup(3, bindGroup83, []); |
| } catch {} |
| try { |
| renderPassEncoder40.setStencilReference(2598); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline23); |
| } catch {} |
| try { |
| await shaderModule6.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder148.copyBufferToBuffer(buffer71, 1624, buffer122, 1788, 160); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| if (!arrayBuffer25.detached) { new Uint8Array(arrayBuffer25).fill(0x55); }; |
| } catch {} |
| let bindGroup192 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [{binding: 396, resource: {buffer: buffer165, offset: 5120}}], |
| }); |
| let commandBuffer20 = commandEncoder148.finish(); |
| try { |
| computePassEncoder108.setBindGroup(3, bindGroup92); |
| } catch {} |
| let bindGroup193 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 396, resource: {buffer: buffer165, offset: 1792}}], |
| }); |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder64.setIndexBuffer(buffer86, 'uint16', 7_782, 938); |
| } catch {} |
| let commandEncoder276 = device0.createCommandEncoder(); |
| let computePassEncoder229 = commandEncoder276.beginComputePass({}); |
| try { |
| computePassEncoder167.setBindGroup(3, bindGroup113, new Uint32Array(2006), 309, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(2, bindGroup179); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle12, renderBundle11, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer36, 'uint16', 36, 4_463); |
| } catch {} |
| let sampler204 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.80, |
| compare: 'less-equal', |
| }); |
| try { |
| computePassEncoder152.setBindGroup(2, bindGroup112); |
| } catch {} |
| try { |
| computePassEncoder101.setBindGroup(1, bindGroup157, new Uint32Array(2298), 836, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(148).fill(118), /* required buffer size: 148 */ |
| {offset: 148}, {width: 27, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder96.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder229.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(2, bindGroup122, new Uint32Array(655), 112, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture250, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(22).fill(153), /* required buffer size: 22 */ |
| {offset: 22, bytesPerRow: 136}, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = texture69.label; |
| } catch {} |
| let textureView295 = texture240.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5}); |
| let sampler205 = device0.createSampler({ |
| label: '\u{1f6ce}\u374c\u05a7\u35b4\u{1fc2e}\u6db1\u{1fe7e}\u3495', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 98.72, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder17.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder17.setBlendConstant({ r: 434.4, g: 386.6, b: 831.5, a: -405.4, }); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let textureView296 = texture248.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let sampler206 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder114.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder74.setBindGroup(3, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline27); |
| } catch {} |
| let buffer200 = device0.createBuffer({size: 19199, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder200.setBindGroup(0, bindGroup180, new Uint32Array(11), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder61.setBindGroup(2, bindGroup94, new Uint32Array(3852), 182, 0); |
| } catch {} |
| try { |
| renderPassEncoder54.executeBundles([renderBundle16]); |
| } catch {} |
| let img8 = await imageWithData(22, 8, '#10101010', '#20202020'); |
| try { |
| computePassEncoder61.label = '\u070a\u61b8\u7be1\u009b\u07ef\u05ae\u24b6'; |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture117, |
| mipLevel: 0, |
| origin: {x: 2, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(29).fill(121), /* required buffer size: 29 */ |
| {offset: 29, bytesPerRow: 120, rowsPerImage: 54}, {width: 29, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup194 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 8, resource: {buffer: buffer66, offset: 0, size: 240}}], |
| }); |
| let buffer201 = device0.createBuffer({size: 5330, usage: GPUBufferUsage.INDEX}); |
| let textureView297 = texture141.createView({dimension: '2d-array'}); |
| let sampler207 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'linear'}); |
| try { |
| renderPassEncoder68.executeBundles([renderBundle10, renderBundle10]); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let textureView298 = texture48.createView({}); |
| try { |
| computePassEncoder126.setBindGroup(2, bindGroup51, new Uint32Array(768), 192, 0); |
| } catch {} |
| let bindGroup195 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout83, |
| entries: [{binding: 216, resource: textureView230}, {binding: 8, resource: {buffer: buffer69, offset: 0}}], |
| }); |
| let texture301 = device0.createTexture({ |
| size: {width: 2}, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder95.setBindGroup(2, bindGroup136); |
| } catch {} |
| try { |
| computePassEncoder206.setBindGroup(2, bindGroup39, new Uint32Array(254), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder55.setViewport(28.03461752856692, 4.375276031720025, 13.525690115659282, 12.481387151857056, 0.8420359862725488, 0.93392518324153); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(7, buffer147, 0, 339); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData28, |
| origin: { x: 3, y: 5 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 165, y: 77, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer202 = device0.createBuffer({ |
| size: 4221, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture302 = device0.createTexture({ |
| size: [60], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder13.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer90, 404, new Int16Array(30081), 575, 12); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture42.label; |
| } catch {} |
| let bindGroup196 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout80, |
| entries: [{binding: 8, resource: {buffer: buffer63, offset: 0}}], |
| }); |
| let sampler208 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 66.75, |
| compare: 'greater', |
| maxAnisotropy: 3, |
| }); |
| let buffer203 = device0.createBuffer({size: 10728, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let texture303 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView299 = texture80.createView({}); |
| let sampler209 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 96.54}); |
| let externalTexture43 = device0.importExternalTexture({source: videoFrame36}); |
| try { |
| computePassEncoder144.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder142.setBindGroup(0, bindGroup120, new Uint32Array(1128), 160, 0); |
| } catch {} |
| try { |
| buffer177.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer20]); |
| } catch {} |
| let promise31 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5}}); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer204 = device0.createBuffer({size: 19253, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let texture304 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder57.setBindGroup(1, bindGroup163, new Uint32Array(302), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder72.setIndexBuffer(buffer192, 'uint32', 2_676, 78); |
| } catch {} |
| try { |
| renderPassEncoder54.setPipeline(pipeline3); |
| } catch {} |
| let pipeline72 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, entryPoint: 'compute8', constants: {}}}); |
| try { |
| adapter0.label = '\ub1a6\u57d8\ubf7e\uf5f0\u{1ff20}'; |
| } catch {} |
| let textureView300 = texture20.createView({dimension: '1d'}); |
| try { |
| computePassEncoder162.setBindGroup(1, bindGroup156); |
| } catch {} |
| try { |
| computePassEncoder213.setBindGroup(2, bindGroup40, new Uint32Array(936), 97, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer105, 'uint16', 768, 636); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline39); |
| } catch {} |
| let arrayBuffer26 = buffer45.getMappedRange(352, 48); |
| try { |
| gpuCanvasContext11.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipeline73 = await device0.createComputePipelineAsync({layout: pipelineLayout21, compute: {module: shaderModule0, constants: {}}}); |
| let shaderModule10 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| requires pointer_composite_access; |
| |
| fn fn0() -> vec4u { |
| var out: vec4u; |
| let ptr175: ptr<storage, array<array<f16, 1>, 1>, read> = &(*&buffer205)[26][0][0]; |
| let ptr176: ptr<storage, f16, read> = &buffer205[26][0][u32(unconst_u32(209))][u32(unconst_u32(444))][0]; |
| let ptr177: ptr<storage, f16, read> = &(*&buffer205)[26][0][u32(unconst_u32(11))][u32(unconst_u32(145))][0]; |
| let ptr178: ptr<storage, f16, read> = &buffer205[u32(unconst_u32(10))][u32(unconst_u32(76))][0][u32(unconst_u32(268))][0]; |
| let ptr179: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &buffer205[26][u32(unconst_u32(113))]; |
| let ptr180: ptr<storage, f16, read> = &(*&buffer205)[26][0][u32(unconst_u32(100))][0][u32(unconst_u32(426))]; |
| out |= unpack4xU8(u32((*&buffer205)[u32(unconst_u32(250))][u32(unconst_u32(62))][u32(unconst_u32(2))][u32(unconst_u32(265))][0])); |
| let ptr181: ptr<storage, f16, read> = &buffer205[26][0][u32(unconst_u32(253))][u32(unconst_u32(22))][0]; |
| let ptr182: ptr<storage, f16, read> = &(*ptr179)[u32(unconst_u32(7))][0][u32(unconst_u32(341))]; |
| return out; |
| _ = buffer205; |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentOutput12 { |
| @builtin(sample_mask) f0: u32, |
| @location(5) f1: vec4u, |
| @location(0) @interpolate(flat) f2: vec4u, |
| } |
| |
| @group(0) @binding(8) var<storage, read> buffer205: array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 27>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| f0: array<atomic<u32>>, |
| } |
| |
| @fragment |
| fn fragment12() -> FragmentOutput12 { |
| var out: FragmentOutput12; |
| out.f1 &= unpack4xU8(u32((*&buffer205)[26][0][u32(unconst_u32(360))][u32(unconst_u32(86))][u32(unconst_u32(76))])); |
| let ptr183: ptr<storage, array<array<f16, 1>, 1>, read> = &buffer205[u32(unconst_u32(49))][u32(unconst_u32(70))][u32(unconst_u32(197))]; |
| out.f2 = unpack4xU8(u32(buffer205[u32(unconst_u32(91))][0][u32(unconst_u32(147))][u32(unconst_u32(178))][0])); |
| let ptr184: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer205)[u32(unconst_u32(53))][0]; |
| out.f1 = vec4u(u32(buffer205[u32(unconst_u32(307))][u32(unconst_u32(59))][u32(unconst_u32(83))][u32(unconst_u32(34))][0])); |
| let ptr185: ptr<storage, f16, read> = &buffer205[26][u32(unconst_u32(179))][0][0][u32(unconst_u32(97))]; |
| out.f2 &= vec4u(u32((*&buffer205)[26][u32(unconst_u32(161))][0][0][0])); |
| let ptr186: ptr<storage, array<f16, 1>, read> = &buffer205[26][0][0][0]; |
| out.f2 -= vec4u(u32((*&buffer205)[26][u32(unconst_u32(72))][0][0][0])); |
| var vf119: vec4f = faceForward(vec4f(unconst_f32(0.4875), unconst_f32(0.02107), unconst_f32(0.1270), unconst_f32(0.4729)), vec4f(f32((*&buffer205)[26][u32(unconst_u32(306))][0][0][u32(unconst_u32(269))])), vec4f(unconst_f32(0.07854), unconst_f32(0.1603), unconst_f32(0.2225), unconst_f32(0.1082))); |
| let ptr187: ptr<storage, array<f16, 1>, read> = &buffer205[26][u32(unconst_u32(92))][u32(unconst_u32(100))][0]; |
| let ptr188: ptr<storage, f16, read> = &(*&buffer205)[u32(unconst_u32(30))][0][u32(unconst_u32(14))][u32(unconst_u32(259))][0]; |
| let ptr189: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 27>, read> = &buffer205; |
| let ptr190: ptr<storage, f16, read> = &(*ptr189)[u32(unconst_u32(3))][0][u32((*&buffer205)[u32(unconst_u32(582))][0][0][u32(unconst_u32(311))][0])][u32(unconst_u32(793))][u32(unconst_u32(513))]; |
| out.f0 = u32((*&buffer205)[26][0][0][0][0]); |
| let ptr191: ptr<storage, array<array<f16, 1>, 1>, read> = &(*ptr189)[u32(unconst_u32(16))][0][u32(unconst_u32(314))]; |
| let ptr192: ptr<storage, array<f16, 1>, read> = &buffer205[u32(unconst_u32(28))][0][u32(unconst_u32(146))][u32(unconst_u32(290))]; |
| out.f2 >>= unpack4xU8(u32((*ptr191)[0][u32(unconst_u32(175))])); |
| out.f2 = unpack4xU8(u32((*ptr189)[26][0][u32(unconst_u32(63))][u32(buffer205[u32(unconst_u32(66))][0][u32(unconst_u32(267))][0][0])][u32(unconst_u32(554))])); |
| let ptr193: ptr<storage, array<array<f16, 1>, 1>, read> = &(*ptr184)[u32(unconst_u32(46))]; |
| out.f0 <<= u32((*ptr187)[0]); |
| let ptr194: ptr<storage, array<f16, 1>, read> = &buffer205[26][0][0][0]; |
| let ptr195: ptr<storage, f16, read> = &buffer205[u32((*&buffer205)[u32(unconst_u32(501))][u32(unconst_u32(188))][0][0][u32(unconst_u32(160))])][0][u32((*&buffer205)[u32(unconst_u32(115))][u32(unconst_u32(72))][0][0][0])][0][u32(unconst_u32(9))]; |
| out.f0 <<= u32((*ptr191)[u32(unconst_u32(371))][0]); |
| return out; |
| _ = buffer205; |
| }`, |
| }); |
| let querySet44 = device0.createQuerySet({type: 'occlusion', count: 607}); |
| try { |
| renderPassEncoder53.setBlendConstant({ r: 578.9, g: 965.5, b: -119.4, a: -950.1, }); |
| } catch {} |
| let sampler210 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 62.77}); |
| let pipeline74 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'always', |
| stencilBack: {failOp: 'keep', passOp: 'keep'}, |
| stencilWriteMask: 665730465, |
| depthBiasClamp: 157.25358971935026, |
| }, |
| vertex: { |
| module: shaderModule8, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 284, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x4', offset: 16, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 12, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| externalTexture18.label = '\ucd7b\u7251\u3f2e\u0aa2\u401e\u96b8\u{1f79f}'; |
| } catch {} |
| let textureView301 = texture297.createView({}); |
| let textureView302 = texture105.createView({mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup132); |
| } catch {} |
| try { |
| renderPassEncoder69.setIndexBuffer(buffer115, 'uint32', 472, 438); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture266, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(4_078).fill(28), /* required buffer size: 4_078 */ |
| {offset: 18, bytesPerRow: 116, rowsPerImage: 35}, {width: 0, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let videoFrame40 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'unspecified', transfer: 'smpte240m'} }); |
| let texture305 = device0.createTexture({ |
| size: [120, 40, 19], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder14.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let promise32 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let recycledExplicitBindGroupLayout33 = pipeline58.getBindGroupLayout(0); |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup78); |
| } catch {} |
| try { |
| renderPassEncoder75.setIndexBuffer(buffer105, 'uint16', 1_556, 687); |
| } catch {} |
| try { |
| renderPassEncoder65.setPipeline(pipeline29); |
| } catch {} |
| let buffer206 = device0.createBuffer({ |
| size: 1574, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let sampler211 = device0.createSampler({addressModeU: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer82, 'uint32', 76, 31); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline57); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(4, buffer163, 0, 917); |
| } catch {} |
| let autogeneratedBindGroupLayout106 = pipeline64.getBindGroupLayout(0); |
| let texture306 = device0.createTexture({ |
| label: '\u{1fcfd}\u0e28\u5b9c', |
| size: {width: 240, height: 80, depthOrArrayLayers: 104}, |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView303 = texture276.createView({mipLevelCount: 1}); |
| let sampler212 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 87.65, |
| compare: 'equal', |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder217.setBindGroup(1, bindGroup89); |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(0, bindGroup105); |
| } catch {} |
| try { |
| renderPassEncoder56.setBlendConstant({ r: -175.3, g: -774.0, b: 632.9, a: 817.7, }); |
| } catch {} |
| try { |
| renderPassEncoder78.setIndexBuffer(buffer112, 'uint32', 448, 201); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline44); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(5, buffer98, 0, 463); |
| } catch {} |
| let arrayBuffer27 = buffer65.getMappedRange(1296, 12); |
| document.body.append(img4); |
| let texture307 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 16}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder40 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| try { |
| computePassEncoder157.setBindGroup(0, bindGroup143); |
| } catch {} |
| try { |
| computePassEncoder76.setBindGroup(1, bindGroup115, new Uint32Array(941), 312, 0); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(2, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder23.setScissorRect(0, 2, 14, 1); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(3, bindGroup109); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(3, bindGroup99, new Uint32Array(600), 51, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline32); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 249, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer207 = device0.createBuffer({ |
| size: 3022, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let renderBundleEncoder41 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| let externalTexture44 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| renderPassEncoder65.setBindGroup(2, bindGroup172, new Uint32Array(1061), 300, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer185, 'uint16', 166, 65); |
| } catch {} |
| try { |
| renderPassEncoder57.setVertexBuffer(0, buffer7, 900, 548); |
| } catch {} |
| let arrayBuffer28 = buffer45.getMappedRange(400, 0); |
| try { |
| await promise32; |
| } catch {} |
| let sampler213 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.10, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder177.setBindGroup(1, bindGroup190, new Uint32Array(2712), 144, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer72, 'uint32', 292, 168); |
| } catch {} |
| let arrayBuffer29 = buffer111.getMappedRange(3952, 160); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame26, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 32, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler214 = device0.createSampler({addressModeV: 'clamp-to-edge', magFilter: 'nearest', mipmapFilter: 'nearest'}); |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer17); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(1, bindGroup39); |
| } catch {} |
| let buffer208 = device0.createBuffer({size: 5334, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC, mappedAtCreation: false}); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup39, new Uint32Array(2375), 54, 0); |
| } catch {} |
| try { |
| renderPassEncoder77.setBindGroup(0, bindGroup75, new Uint32Array(2908), 383, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer78, 'uint32', 316, 242); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline74); |
| } catch {} |
| try { |
| renderBundleEncoder41.setBindGroup(2, bindGroup178, new Uint32Array(123), 29, 0); |
| } catch {} |
| try { |
| renderBundleEncoder41.setVertexBuffer(3, buffer92, 0, 109); |
| } catch {} |
| let veryExplicitBindGroupLayout41 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 54, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView304 = texture129.createView({dimension: 'cube', arrayLayerCount: 6}); |
| try { |
| computePassEncoder183.setBindGroup(0, bindGroup71); |
| } catch {} |
| try { |
| computePassEncoder108.setBindGroup(0, bindGroup123, new Uint32Array(955), 54, 0); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(3, bindGroup115); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer46, 'uint32', 608, 237); |
| } catch {} |
| try { |
| renderPassEncoder66.setVertexBuffer(1, buffer123); |
| } catch {} |
| try { |
| renderBundleEncoder41.setBindGroup(0, bindGroup196); |
| } catch {} |
| try { |
| renderBundleEncoder41.setIndexBuffer(buffer85, 'uint32', 464, 672); |
| } catch {} |
| try { |
| renderBundleEncoder41.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder41.setVertexBuffer(0, buffer33, 0); |
| } catch {} |
| try { |
| buffer66.unmap(); |
| } catch {} |
| try { |
| computePassEncoder32.pushDebugGroup('\u0970'); |
| } catch {} |
| try { |
| computePassEncoder219.setBindGroup(0, bindGroup115); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup123); |
| } catch {} |
| try { |
| renderPassEncoder55.setPipeline(pipeline4); |
| } catch {} |
| let autogeneratedBindGroupLayout107 = pipeline0.getBindGroupLayout(0); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup110); |
| } catch {} |
| try { |
| renderPassEncoder74.setPipeline(pipeline63); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(4, buffer147); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline54); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer153, 188, new Float32Array(16875), 869, 116); |
| } catch {} |
| document.body.prepend(canvas5); |
| let autogeneratedBindGroupLayout108 = pipeline10.getBindGroupLayout(0); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup133); |
| } catch {} |
| try { |
| computePassEncoder183.setBindGroup(3, bindGroup125, new Uint32Array(869), 135, 0); |
| } catch {} |
| try { |
| renderPassEncoder71.setBindGroup(2, bindGroup179); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(1, bindGroup99, new Uint32Array(119), 19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer9, 'uint32', 3_636, 329); |
| } catch {} |
| try { |
| renderBundleEncoder41.setVertexBuffer(0, buffer182, 668, 741); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let buffer209 = device0.createBuffer({ |
| size: 515, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup39); |
| } catch {} |
| try { |
| computePassEncoder117.setBindGroup(3, bindGroup196, new Uint32Array(2294), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(3, bindGroup120); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer94, 'uint16', 20, 27); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(0, bindGroup43); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline54); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(3, buffer204, 0, 6_509); |
| } catch {} |
| try { |
| adapter0.label = '\u0f37\uacfd\u0439\uca18\u{1fe44}\ufa0b\u7374\u912a\u7aaa\u{1fbf1}\u{1ff07}'; |
| } catch {} |
| let bindGroup197 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout86, |
| entries: [{binding: 8, resource: {buffer: buffer207, offset: 256, size: 128}}], |
| }); |
| let texture308 = device0.createTexture({ |
| size: [30, 10, 79], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup184); |
| } catch {} |
| try { |
| renderPassEncoder22.beginOcclusionQuery(62); |
| } catch {} |
| try { |
| renderPassEncoder22.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle20, renderBundle7, renderBundle18, renderBundle4, renderBundle8, renderBundle18, renderBundle7, renderBundle2, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder28.setScissorRect(72, 5, 47, 60); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer86, 'uint16', 4_380, 517); |
| } catch {} |
| try { |
| renderBundleEncoder41.setPipeline(pipeline19); |
| } catch {} |
| try { |
| buffer140.unmap(); |
| } catch {} |
| let textureView305 = texture308.createView({dimension: '2d', baseArrayLayer: 34}); |
| let texture309 = device0.createTexture({size: [120, 40, 28], format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView306 = texture52.createView({dimension: '1d'}); |
| let renderBundle40 = renderBundleEncoder41.finish({}); |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder84.insertDebugMarker('\u049a'); |
| } catch {} |
| let promise33 = device0.queue.onSubmittedWorkDone(); |
| let imageData49 = new ImageData(28, 4); |
| try { |
| computePassEncoder100.end(); |
| } catch {} |
| try { |
| renderPassEncoder55.setBindGroup(3, bindGroup107); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer109, 'uint16', 54, 7); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(0, bindGroup24, new Uint32Array(89), 16, 0); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4348 */ |
| offset: 4348, |
| bytesPerRow: 13824, |
| rowsPerImage: 672, |
| buffer: buffer133, |
| }, { |
| texture: texture162, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline75 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout21, |
| fragment: { |
| module: shaderModule8, |
| entryPoint: 'fragment9', |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 120, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32x2', offset: 4, shaderLocation: 8}, |
| {format: 'float32x3', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x4', offset: 44, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 32, shaderLocation: 14}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 8, shaderLocation: 3}, |
| {format: 'sint32', offset: 28, shaderLocation: 15}, |
| {format: 'float32', offset: 4, shaderLocation: 7}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 9}, |
| {format: 'sint16x4', offset: 32, shaderLocation: 12}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 5}, |
| {format: 'sint32', offset: 12, shaderLocation: 4}, |
| {format: 'snorm8x2', offset: 6, shaderLocation: 10}, |
| {format: 'uint8x4', offset: 40, shaderLocation: 11}, |
| ], |
| }, |
| {arrayStride: 20, attributes: [{format: 'float32', offset: 0, shaderLocation: 6}]}, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| try { |
| if (!arrayBuffer28.detached) { new Uint8Array(arrayBuffer28).fill(0x55); }; |
| } catch {} |
| try { |
| await promise33; |
| } catch {} |
| let bindGroup198 = device0.createBindGroup({ |
| label: '\u01ef\u5d9f\u0568\u6e06\u{1f65e}\u8def\u8388', |
| layout: autogeneratedBindGroupLayout59, |
| entries: [{binding: 8, resource: {buffer: buffer57, offset: 0, size: 152}}], |
| }); |
| let renderPassEncoder80 = commandEncoder64.beginRenderPass({colorAttachments: [{view: textureView267, loadOp: 'clear', storeOp: 'store'}]}); |
| let sampler215 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| renderPassEncoder69.setVertexBuffer(5, buffer79, 52, 25); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline44); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData40, |
| origin: { x: 0, y: 5 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 122, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer210 = device0.createBuffer({size: 27510, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let texture310 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 15}, |
| format: 'r16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let sampler216 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| renderPassEncoder53.setBindGroup(1, bindGroup35, new Uint32Array(1289), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer109, 'uint16', 26, 2); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline13); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 1, y: 24 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 240, y: 51, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline76 = device0.createRenderPipeline({ |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule10, |
| targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule7, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 612, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x4', offset: 104, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 64, shaderLocation: 4}, |
| {format: 'uint8x4', offset: 56, shaderLocation: 7}, |
| {format: 'snorm8x4', offset: 48, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'front'}, |
| }); |
| await gc(); |
| let texture311 = device0.createTexture({ |
| size: {width: 60, height: 20, depthOrArrayLayers: 73}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg32sint'], |
| }); |
| let textureView307 = texture142.createView({baseMipLevel: 0}); |
| let sampler217 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 96.40, |
| }); |
| try { |
| computePassEncoder119.setBindGroup(0, bindGroup91); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder119); computePassEncoder119.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder119.end(); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer171, 'uint16', 310, 132); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(3, buffer121, 7_088, 57); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder138.copyBufferToBuffer(buffer133, 936, buffer104, 236, 552); |
| } catch {} |
| try { |
| commandEncoder138.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 384 */ |
| offset: 384, |
| bytesPerRow: 1792, |
| buffer: buffer42, |
| }, { |
| texture: texture3, |
| mipLevel: 1, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder138.resolveQuerySet(querySet28, 10, 0, buffer204, 4608); |
| } catch {} |
| let promise34 = device0.queue.onSubmittedWorkDone(); |
| let commandBuffer21 = commandEncoder138.finish(); |
| let texture312 = device0.createTexture({ |
| size: [60], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder90.setBindGroup(3, bindGroup62, new Uint32Array(4046), 329, 0); |
| } catch {} |
| try { |
| renderPassEncoder76.setBindGroup(0, bindGroup67, new Uint32Array(2357), 270, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(2, bindGroup97); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture145, |
| mipLevel: 0, |
| origin: {x: 107, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(165).fill(16), /* required buffer size: 165 */ |
| {offset: 165, bytesPerRow: 102}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 40, y: 71, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder277 = device0.createCommandEncoder({}); |
| let texture313 = device0.createTexture({ |
| size: [60, 20, 19], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView308 = texture195.createView({mipLevelCount: 1}); |
| let computePassEncoder230 = commandEncoder277.beginComputePass({label: '\u0d66\uea44\uab2e\u8f8e\u0aac\u03c5\u0d52\u22a5\u{1f989}'}); |
| try { |
| computePassEncoder220.setBindGroup(1, bindGroup159, new Uint32Array(401), 52, 0); |
| } catch {} |
| try { |
| await buffer75.mapAsync(GPUMapMode.READ, 0, 308); |
| } catch {} |
| let pipeline77 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule9, entryPoint: 'compute10'}}); |
| let autogeneratedBindGroupLayout109 = pipeline33.getBindGroupLayout(0); |
| try { |
| computePassEncoder220.setBindGroup(1, bindGroup1, new Uint32Array(4570), 1_386, 0); |
| } catch {} |
| try { |
| computePassEncoder230.setPipeline(pipeline45); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(4, buffer132, 0, 952); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline3); |
| } catch {} |
| let recycledExplicitBindGroupLayout34 = pipeline37.getBindGroupLayout(0); |
| try { |
| computePassEncoder152.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer21, 'uint16', 286, 2_402); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer112, 756, 665); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(1, bindGroup37, new Uint32Array(1459), 148, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u0936'); |
| } catch {} |
| try { |
| gpuCanvasContext11.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| } catch {} |
| await gc(); |
| try { |
| adapter0.label = '\u{1fbec}\u9728\uaa90'; |
| } catch {} |
| let bindGroup199 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout26, |
| entries: [{binding: 8, resource: {buffer: buffer98, offset: 512, size: 456}}], |
| }); |
| let texture314 = device0.createTexture({ |
| size: [60, 20, 1], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder48.setBindGroup(2, bindGroup125, new Uint32Array(1699), 719, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup90, new Uint32Array(507), 252, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(2, buffer207); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let offscreenCanvas10 = new OffscreenCanvas(61, 209); |
| let texture315 = device0.createTexture({size: [30, 10, 22], format: 'rgba16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder117.setBindGroup(0, bindGroup55, new Uint32Array(1461), 21, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(6, buffer153, 348); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(4, buffer181); |
| } catch {} |
| let renderBundle41 = renderBundleEncoder40.finish({}); |
| try { |
| renderPassEncoder32.setBindGroup(3, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder16.setStencilReference(109); |
| } catch {} |
| let gpuCanvasContext14 = offscreenCanvas10.getContext('webgpu'); |
| let textureView309 = texture195.createView({format: 'r32sint', mipLevelCount: 1}); |
| let textureView310 = texture103.createView({dimension: '2d', baseArrayLayer: 1}); |
| let renderBundleEncoder42 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], stencilReadOnly: true}); |
| let renderBundle42 = renderBundleEncoder42.finish(); |
| let sampler218 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 38.21, |
| lodMaxClamp: 65.22, |
| maxAnisotropy: 7, |
| }); |
| document.body.prepend(canvas1); |
| let bindGroup200 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout26, |
| entries: [{binding: 8, resource: {buffer: buffer163, offset: 256, size: 640}}], |
| }); |
| try { |
| computePassEncoder112.setBindGroup(2, bindGroup194); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer21]); |
| } catch {} |
| let promise35 = device0.queue.onSubmittedWorkDone(); |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup48, new Uint32Array(2580), 829, 0); |
| } catch {} |
| try { |
| renderPassEncoder72.setVertexBuffer(1, buffer129, 0, 789); |
| } catch {} |
| let arrayBuffer30 = buffer75.getMappedRange(0, 28); |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let texture316 = device0.createTexture({ |
| size: [2, 2, 13], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder42.setBindGroup(1, bindGroup117); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup194, new Uint32Array(365), 3, 0); |
| } catch {} |
| try { |
| computePassEncoder32.popDebugGroup(); |
| } catch {} |
| let veryExplicitBindGroupLayout42 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 124, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let textureView311 = texture266.createView({dimension: '2d', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder37.setPipeline(pipeline26); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer211 = device0.createBuffer({size: 24780, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| try { |
| computePassEncoder54.setBindGroup(0, bindGroup130, new Uint32Array(2226), 1_514, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(1, bindGroup8, new Uint32Array(1316), 24, 0); |
| } catch {} |
| try { |
| computePassEncoder219.insertDebugMarker('\u0577'); |
| } catch {} |
| try { |
| await promise34; |
| } catch {} |
| let texture317 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 147}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView312 = texture317.createView({baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 0}); |
| let sampler219 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMinClamp: 87.88, lodMaxClamp: 95.32}); |
| try { |
| renderPassEncoder45.setBindGroup(2, bindGroup93, new Uint32Array(4197), 322, 0); |
| } catch {} |
| try { |
| renderPassEncoder76.insertDebugMarker('\u0354'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(173).fill(129), /* required buffer size: 173 */ |
| {offset: 173}, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture318 = device0.createTexture({ |
| size: {width: 120, height: 40, depthOrArrayLayers: 29}, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder173.setBindGroup(3, bindGroup78); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(1, buffer197, 500, 1_663); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 19, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 12, y: 24, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup201 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 258, resource: textureView84}, |
| {binding: 116, resource: {buffer: buffer178, offset: 0, size: 368}}, |
| ], |
| }); |
| let buffer212 = device0.createBuffer({size: 10245, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let sampler220 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.64, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup175); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline27); |
| } catch {} |
| try { |
| gpuCanvasContext7.unconfigure(); |
| } catch {} |
| let buffer213 = device0.createBuffer({ |
| size: 31805, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let externalTexture45 = device0.importExternalTexture({source: videoFrame33, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| let autogeneratedBindGroupLayout110 = pipeline0.getBindGroupLayout(0); |
| try { |
| computePassEncoder222.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder158.setBindGroup(1, bindGroup71, new Uint32Array(840), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder79.setBindGroup(0, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(3, bindGroup49, new Uint32Array(741), 104, 0); |
| } catch {} |
| try { |
| renderPassEncoder71.setViewport(191.4923825879517, 75.41452260315782, 29.49545320154882, 1.3340599134133233, 0.26035078142393975, 0.3213653394982892); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer40, 'uint32', 2_508, 997); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline27); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer187, 132, new Int16Array(7248), 61, 692); |
| } catch {} |
| try { |
| await promise35; |
| } catch {} |
| let autogeneratedBindGroupLayout111 = pipeline6.getBindGroupLayout(0); |
| let pipelineLayout24 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout8, veryExplicitBindGroupLayout42]}); |
| let querySet45 = device0.createQuerySet({type: 'occlusion', count: 513}); |
| let texture319 = device0.createTexture({ |
| size: {width: 30, height: 10, depthOrArrayLayers: 116}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder58.setBindGroup(3, bindGroup110, new Uint32Array(4152), 1_058, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer21, 'uint32', 5_668, 673); |
| } catch {} |
| try { |
| renderPassEncoder77.setPipeline(pipeline54); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(4, buffer172, 0); |
| } catch {} |
| try { |
| buffer82.unmap(); |
| } catch {} |
| let texture320 = device0.createTexture({ |
| size: {width: 240}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture321 = gpuCanvasContext4.getCurrentTexture(); |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup121); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer36, 'uint16', 670, 392); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline24); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData48, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 2, y: 30, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline78 = device0.createRenderPipeline({ |
| layout: pipelineLayout10, |
| multisample: {}, |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rgba8sint', writeMask: 0}]}, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: false, |
| depthCompare: 'not-equal', |
| stencilBack: {failOp: 'keep'}, |
| stencilReadMask: 176315360, |
| stencilWriteMask: 289449842, |
| depthBias: -1904353400, |
| depthBiasSlopeScale: 0.0, |
| depthBiasClamp: 492.55528816237074, |
| }, |
| vertex: { |
| module: shaderModule8, |
| buffers: [ |
| { |
| arrayStride: 440, |
| attributes: [ |
| {format: 'sint32x4', offset: 24, shaderLocation: 14}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'none'}, |
| }); |
| let buffer214 = device0.createBuffer({size: 1081, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture322 = device0.createTexture({ |
| size: [30, 10, 36], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder199.setBindGroup(3, bindGroup155, new Uint32Array(64), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup11, new Uint32Array(2015), 178, 0); |
| } catch {} |
| try { |
| renderPassEncoder56.insertDebugMarker('\u{1f7bc}'); |
| } catch {} |
| try { |
| gpuCanvasContext7.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture31.label; |
| } catch {} |
| let autogeneratedBindGroupLayout112 = pipeline9.getBindGroupLayout(0); |
| let bindGroup202 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout74, |
| entries: [{binding: 8, resource: {buffer: buffer62, offset: 3072}}], |
| }); |
| let textureView313 = texture322.createView({}); |
| let texture323 = device0.createTexture({ |
| size: [120, 40, 147], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView314 = texture110.createView({label: '\u0618\ub66e\u0d93', aspect: 'all'}); |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup20, new Uint32Array(1286), 84, 0); |
| } catch {} |
| try { |
| renderPassEncoder79.setIndexBuffer(buffer40, 'uint16', 2_486, 3_854); |
| } catch {} |
| try { |
| renderPassEncoder54.setPipeline(pipeline43); |
| } catch {} |
| let promise36 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| let buffer215 = device0.createBuffer({ |
| size: 2955, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture324 = device0.createTexture({ |
| size: {width: 240, height: 80, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup54, new Uint32Array(1308), 318, 0); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(2, buffer189); |
| } catch {} |
| let bindGroup203 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout72, |
| entries: [{binding: 8, resource: {buffer: buffer154, offset: 2816}}], |
| }); |
| let textureView315 = texture233.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| try { |
| computePassEncoder67.setBindGroup(2, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup166); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(3, bindGroup33, new Uint32Array(3128), 310, 0); |
| } catch {} |
| try { |
| renderPassEncoder65.setIndexBuffer(buffer82, 'uint32', 0, 1_358); |
| } catch {} |
| try { |
| renderPassEncoder80.setVertexBuffer(4, buffer19, 600, 367); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| try { |
| await promise36; |
| } catch {} |
| document.body.append(canvas5); |
| try { |
| computePassEncoder183.setBindGroup(0, bindGroup109); |
| } catch {} |
| try { |
| computePassEncoder142.setBindGroup(0, bindGroup19, new Uint32Array(1362), 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup198); |
| } catch {} |
| try { |
| renderPassEncoder75.executeBundles([renderBundle37]); |
| } catch {} |
| try { |
| renderPassEncoder80.setIndexBuffer(buffer125, 'uint32', 1_544, 389); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline54); |
| } catch {} |
| let arrayBuffer31 = buffer75.getMappedRange(208, 0); |
| try { |
| device0.queue.writeBuffer(buffer163, 160, new Int16Array(12081), 1171, 20); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1702, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 692, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup204 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 396, resource: {buffer: buffer8, offset: 256, size: 32}}], |
| }); |
| let buffer216 = device0.createBuffer({ |
| size: 439, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder16.executeBundles([renderBundle16, renderBundle1, renderBundle16]); |
| } catch {} |
| try { |
| renderPassEncoder63.setPipeline(pipeline51); |
| } catch {} |
| let bindGroup205 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout15, |
| entries: [{binding: 396, resource: {buffer: buffer140, offset: 512, size: 32}}], |
| }); |
| let buffer217 = device0.createBuffer({size: 5338, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView316 = texture79.createView({}); |
| try { |
| computePassEncoder166.setBindGroup(1, bindGroup107); |
| } catch {} |
| try { |
| computePassEncoder61.setBindGroup(1, bindGroup57, new Uint32Array(4409), 680, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(0, bindGroup41); |
| } catch {} |
| let pipeline79 = device0.createRenderPipeline({ |
| label: '\u6d2c\u04ad\u{1fd4a}\u089c\ua528\u56d9\u{1fe67}\u021e\u0d66\ud9f2', |
| layout: 'auto', |
| multisample: {mask: 0x326206a2}, |
| fragment: { |
| module: shaderModule5, |
| targets: [{format: 'rgba8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}], |
| }, |
| depthStencil: { |
| format: 'depth32float', |
| depthWriteEnabled: true, |
| depthCompare: 'always', |
| stencilReadMask: 364251703, |
| stencilWriteMask: 1514785743, |
| depthBias: 0, |
| depthBiasClamp: 88.09519889749438, |
| }, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 40, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 0, shaderLocation: 13}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 0}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 7}, |
| {format: 'float32x3', offset: 0, shaderLocation: 14}, |
| {format: 'float32x2', offset: 4, shaderLocation: 2}, |
| {format: 'float16x2', offset: 4, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'front', unclippedDepth: false}, |
| }); |
| let recycledAutogeneratedBindGroupLayout7 = pipeline30.getBindGroupLayout(0); |
| try { |
| renderPassEncoder79.setIndexBuffer(buffer44, 'uint32', 64, 91); |
| } catch {} |
| try { |
| renderPassEncoder74.insertDebugMarker('\u3000'); |
| } catch {} |
| let texture325 = device0.createTexture({ |
| size: [30, 10, 1], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder229.setBindGroup(2, bindGroup176); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(1, bindGroup43, new Uint32Array(211), 65, 0); |
| } catch {} |
| try { |
| renderPassEncoder56.beginOcclusionQuery(43); |
| } catch {} |
| try { |
| renderPassEncoder70.executeBundles([renderBundle24]); |
| } catch {} |
| try { |
| renderPassEncoder74.setPipeline(pipeline75); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 11, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 96, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img2); |
| let texture326 = device0.createTexture({ |
| size: [120, 40, 1], |
| mipLevelCount: 2, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder43 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder56.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder75.setPipeline(pipeline75); |
| } catch {} |
| try { |
| renderBundleEncoder43.setBindGroup(0, bindGroup67, []); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline80 = device0.createComputePipeline({layout: pipelineLayout21, compute: {module: shaderModule1}}); |
| let shaderModule11 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| var<workgroup> vw50: atomic<u32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<workgroup> vw43: atomic<u32>; |
| |
| struct T1 { |
| @align(8) @size(248) f0: array<u32>, |
| } |
| |
| @group(0) @binding(216) var tex3: texture_cube_array<f32>; |
| |
| var<workgroup> vw42: atomic<i32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw51: mat4x4h; |
| |
| var<workgroup> vw48: atomic<i32>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw44: array<atomic<i32>, 1>; |
| |
| var<workgroup> vw45: atomic<u32>; |
| |
| struct S7 { |
| @location(13) @interpolate(flat) f0: u32, |
| } |
| |
| struct T0 { |
| f0: array<u32, 1>, |
| } |
| |
| var<workgroup> vw41: array<FragmentOutput13, 1>; |
| |
| struct VertexOutput7 { |
| @builtin(position) f14: vec4f, |
| @location(2) @interpolate(linear, centroid) f15: vec2f, |
| @location(7) f16: vec4h, |
| } |
| |
| struct FragmentOutput13 { |
| @builtin(frag_depth) f0: f32, |
| @location(0) @interpolate(flat) f1: vec4i, |
| } |
| |
| var<workgroup> vw49: FragmentOutput13; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T2 { |
| @align(32) @size(544) f0: array<u32>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw47: FragmentOutput13; |
| |
| var<workgroup> vw46: S7; |
| |
| @vertex |
| fn vertex8(@location(5) a0: u32, @location(14) @interpolate(flat) a1: u32, @location(6) @interpolate(perspective) a2: vec4f, @location(0) @interpolate(perspective, centroid) a3: vec4f, a4: S7, @location(11) @interpolate(flat) a5: i32, @location(2) a6: vec4i, @location(3) @interpolate(perspective, center) a7: vec4f, @location(4) a8: vec2h, @builtin(vertex_index) a9: u32, @location(1) @interpolate(flat) a10: vec2i) -> VertexOutput7 { |
| var out: VertexOutput7; |
| var vf120: i32 = a10[u32(unconst_u32(226))]; |
| var vf121: vec4i = unpack4xI8(u32(unconst_u32(104))); |
| vf121 -= vec4i(i32(mix(f16(unconst_f16(10398.8)), vec2h(textureDimensions(tex3)).r, f16(unconst_f16(6126.0))))); |
| vf120 ^= i32(a2[u32(unconst_u32(87))]); |
| out.f14 = a3; |
| vf120 *= a6.z; |
| out.f14 *= unpack4x8snorm(pack4xU8Clamp(vec4u(unconst_u32(91), unconst_u32(17), unconst_u32(408), unconst_u32(264)))); |
| out.f16 = vec4h(a6); |
| out.f15 = vec2f(bitcast<f32>(a1)); |
| var vf122: f16 = log2(log2(f16(unconst_f16(39209.4)))); |
| out.f14 = vec4f(mix(vec4f(unpack4xU8(u32(unconst_u32(7))))[0], f32(vf120), f32(unconst_f32(0.01225)))); |
| let vf123: vec3f = cross(vec3f(unconst_f32(0.2976), unconst_f32(-0.04829), unconst_f32(0.1135)), vec3f(unconst_f32(0.09422), unconst_f32(-0.2030), unconst_f32(0.1676))); |
| vf121 = vec4i(i32(vf122)); |
| var vf124: u32 = a1; |
| let vf125: vec3f = trunc(vec3f(unconst_f32(0.4202), unconst_f32(0.1167), unconst_f32(-0.01040))); |
| let vf126: f16 = a8[u32(unconst_u32(59))]; |
| let ptr196: ptr<function, f16> = &vf122; |
| out.f16 *= vec4h(f16(a6[u32(unconst_u32(206))])); |
| var vf127: u32 = textureNumLevels(tex3); |
| let vf128: u32 = textureNumLayers(tex3); |
| let vf129: vec4f = a7; |
| var vf130: f32 = mix(f32(unconst_f32(0.03335)), f32(unconst_f32(0.05372)), f32(unconst_f32(0.4873))); |
| return out; |
| _ = tex3; |
| } |
| |
| @fragment |
| fn fragment13() -> FragmentOutput13 { |
| var out: FragmentOutput13; |
| var vf131: u32 = pack2x16unorm(vec2f(unconst_f32(0.2783), unconst_f32(-0.06227))); |
| let vf132: f16 = log(f16(unconst_f16(21730.4))); |
| var vf133: i32 = countOneBits(i32(round(vec4f(unconst_f32(0.01123), unconst_f32(0.00924), unconst_f32(0.1754), unconst_f32(0.5308))).g)); |
| var vf134: f16 = length(vec4h(unconst_f16(14021.5), unconst_f16(4402.3), unconst_f16(8750.8), unconst_f16(-23860.5))); |
| var vf135: vec4f = round(vec4f(unconst_f32(0.00975), unconst_f32(0.01168), unconst_f32(0.2171), unconst_f32(-0.05165))); |
| var vf136: vec4f = round(vec4f(unconst_f32(0.00226), unconst_f32(0.04516), unconst_f32(0.2610), unconst_f32(0.05799))); |
| out.f0 -= bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(102), unconst_u32(47), unconst_u32(252), unconst_u32(60)))); |
| let ptr197: ptr<function, vec4f> = &vf135; |
| let vf137: f16 = log(f16(unconst_f16(5986.2))); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute12(@builtin(num_workgroups) a0: vec3u) { |
| var vf138: f32 = sqrt(f32(unconst_f32(0.02505))); |
| let vf139: u32 = atomicLoad(&vw43); |
| }`, |
| }); |
| let autogeneratedBindGroupLayout113 = pipeline16.getBindGroupLayout(0); |
| let bindGroup206 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 871, resource: textureView37}]}); |
| let buffer218 = device0.createBuffer({ |
| size: 3659, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture327 = device0.createTexture({ |
| size: [120, 40, 14], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup87, new Uint32Array(1602), 311, 0); |
| } catch {} |
| try { |
| renderBundleEncoder43.setPipeline(pipeline75); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let buffer219 = device0.createBuffer({ |
| size: 2261, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder184.setBindGroup(3, bindGroup149, new Uint32Array(5154), 476, 0); |
| } catch {} |
| try { |
| renderBundleEncoder43.setBindGroup(3, bindGroup22, new Uint32Array(43), 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder43.setVertexBuffer(1, buffer44, 0, 11); |
| } catch {} |
| try { |
| renderBundleEncoder43.insertDebugMarker('\u989e'); |
| } catch {} |
| let texture328 = device0.createTexture({ |
| size: [30, 10, 1], |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView317 = texture248.createView({format: 'rgba16sint', mipLevelCount: 1}); |
| let renderBundle43 = renderBundleEncoder43.finish({}); |
| try { |
| computePassEncoder226.setBindGroup(2, bindGroup180, new Uint32Array(615), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(2, bindGroup30, new Uint32Array(98), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder60.end(); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle8, renderBundle18, renderBundle31]); |
| } catch {} |
| try { |
| renderPassEncoder37.setScissorRect(111, 7, 1, 1); |
| } catch {} |
| try { |
| commandEncoder208.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2168 */ |
| offset: 2168, |
| bytesPerRow: 3328, |
| buffer: buffer124, |
| }, { |
| texture: texture247, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame8.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame28.close(); |
| videoFrame29.close(); |
| videoFrame30.close(); |
| videoFrame31.close(); |
| videoFrame33.close(); |
| videoFrame34.close(); |
| videoFrame35.close(); |
| videoFrame36.close(); |
| videoFrame37.close(); |
| videoFrame38.close(); |
| videoFrame39.close(); |
| videoFrame40.close(); |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0() ]; |
| 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?.notifyDone(); |
| }; |
| </script> |
| |
