| <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 promise0 = navigator.gpu.requestAdapter(); |
| let adapter0 = await promise0; |
| let adapter1 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxColorAttachmentBytesPerSample: 32, |
| maxUniformBufferBindingSize: 220235206, |
| maxStorageBufferBindingSize: 142707703, |
| }, |
| }); |
| let texture0 = device0.createTexture({ |
| size: [54, 15, 2], |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let buffer0 = device0.createBuffer({ |
| size: 5624, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let textureView0 = texture0.createView({label: '\uc670\uacbb\u{1f6cf}', dimension: '2d', aspect: 'all', format: 'depth32float-stencil8'}); |
| let texture1 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeBuffer(buffer0, 2108, new Int16Array(4105), 393, 64); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer1 = device0.createBuffer({ |
| size: 13563, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let textureView1 = texture0.createView({dimension: '2d', mipLevelCount: 1}); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let textureView2 = texture0.createView({dimension: '2d', aspect: 'stencil-only'}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass({label: 'p'}); |
| let sampler0 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat'}); |
| try { |
| commandEncoder1.copyTextureToBuffer({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'stencil-only', |
| }, { |
| /* bytesInLastRow: 54 widthInBlocks: 54 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1108 */ |
| offset: 1108, |
| bytesPerRow: 3328, |
| buffer: buffer1, |
| }, {width: 54, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture2 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler1 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| lodMaxClamp: 99.98, |
| compare: 'less', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder0.pushDebugGroup('\u0695'); |
| } catch {} |
| let buffer2 = device0.createBuffer({ |
| size: 7448, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture3 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| dimension: '2d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder1 = commandEncoder1.beginComputePass({label: 'q'}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| computePassEncoder0.insertDebugMarker('\u4521'); |
| } catch {} |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let texture4 = device0.createTexture({ |
| size: [216, 60, 2], |
| sampleCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder2 = commandEncoder2.beginComputePass({label: 'r'}); |
| let textureView3 = texture4.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let texture5 = device0.createTexture({ |
| size: {width: 216}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView4 = texture1.createView({format: 'rgba16float', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder0.popDebugGroup(); |
| } catch {} |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let textureView5 = texture3.createView({dimension: '2d', baseMipLevel: 0}); |
| let textureView6 = texture0.createView({arrayLayerCount: 1}); |
| let computePassEncoder3 = commandEncoder3.beginComputePass({label: 's'}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], stencilReadOnly: true}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer2, 'uint32', 72, 553); |
| } catch {} |
| let texture6 = device0.createTexture({ |
| size: {width: 108}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| buffer1.unmap(); |
| } catch {} |
| await gc(); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let texture7 = device0.createTexture({ |
| size: {width: 432}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView7 = texture3.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder4 = commandEncoder4.beginComputePass({label: 't'}); |
| let renderBundle0 = renderBundleEncoder0.finish({}); |
| let textureView8 = texture7.createView({baseMipLevel: 0}); |
| let textureView9 = texture4.createView({arrayLayerCount: 1}); |
| let sampler2 = device0.createSampler({addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 47.16}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture8 = device0.createTexture({ |
| size: [8, 8, 22], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(49).fill(190), /* required buffer size: 49 */ |
| {offset: 49}, {width: 106, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let sampler3 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 62.80, compare: 'less'}); |
| let texture9 = device0.createTexture({ |
| size: [216, 60, 22], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView10 = texture1.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 138, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 176, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 18, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 237, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| {binding: 473, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| ], |
| }); |
| let buffer3 = device0.createBuffer({ |
| size: 23308, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture10 = device0.createTexture({ |
| size: [108, 30, 2], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder5 = commandEncoder5.beginComputePass({label: 'u'}); |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 32, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 165, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer4 = device0.createBuffer({size: 3688, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let texture11 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder6 = commandEncoder6.beginComputePass({label: 'v'}); |
| try { |
| await promise1; |
| } catch {} |
| let textureView11 = texture10.createView({dimension: '2d', mipLevelCount: 1}); |
| let sampler4 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 45.31, |
| maxAnisotropy: 7, |
| }); |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let computePassEncoder7 = commandEncoder7.beginComputePass({label: 'w'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(79).fill(144), /* required buffer size: 79 */ |
| {offset: 79}, {width: 35, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let textureView12 = texture10.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder8 = commandEncoder8.beginComputePass({label: 'x'}); |
| let canvas0 = document.createElement('canvas'); |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let computePassEncoder9 = commandEncoder9.beginComputePass({label: 'y'}); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 93.56, |
| compare: 'not-equal', |
| }); |
| try { |
| device0.queue.writeBuffer(buffer0, 900, new Int16Array(2303), 420, 468); |
| } catch {} |
| let imageData0 = new ImageData(4, 64); |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 165, resource: textureView0}, {binding: 32, resource: {buffer: buffer2, offset: 768}}], |
| }); |
| let buffer5 = device0.createBuffer({size: 1670, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder10 = device0.createCommandEncoder(); |
| let textureView13 = texture11.createView({dimension: 'cube', baseArrayLayer: 1}); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 30, resource: textureView3}, |
| {binding: 138, resource: textureView11}, |
| {binding: 473, resource: sampler0}, |
| {binding: 176, resource: {buffer: buffer2, offset: 4096}}, |
| {binding: 237, resource: textureView8}, |
| ], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let texture12 = device0.createTexture({ |
| size: {width: 432}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder10 = commandEncoder10.beginComputePass({label: 'z'}); |
| try { |
| computePassEncoder9.insertDebugMarker('\u0476'); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let textureView14 = texture11.createView({dimension: '2d-array', baseArrayLayer: 1, arrayLayerCount: 8}); |
| let texture13 = device0.createTexture({ |
| label: '\u08f0\u{1f743}\uc892\u1598\u7a30\u097c\u{1fcbe}\u5d75\u{1f773}\uda7a', |
| size: [108, 30, 2], |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView15 = texture12.createView({}); |
| let computePassEncoder11 = commandEncoder11.beginComputePass({label: '1'}); |
| let videoFrame0 = new VideoFrame(canvas0, {timestamp: 0}); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let textureView16 = texture3.createView({arrayLayerCount: 1}); |
| let computePassEncoder12 = commandEncoder12.beginComputePass({label: '2'}); |
| let sampler6 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 98.32, maxAnisotropy: 1}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 42, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(235).fill(55), /* required buffer size: 235 */ |
| {offset: 235}, {width: 123, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 23, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup2 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 23, resource: textureView5}]}); |
| let buffer6 = device0.createBuffer({ |
| size: 38551, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let texture14 = device0.createTexture({ |
| size: [216, 60, 41], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup2, new Uint32Array(3579), 300, 0); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 848 */ |
| offset: 848, |
| buffer: buffer2, |
| }, { |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 32, resource: {buffer: buffer2, offset: 0}}, {binding: 165, resource: textureView0}], |
| }); |
| let buffer7 = device0.createBuffer({size: 10899, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let texture15 = device0.createTexture({size: [8], dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder13 = commandEncoder14.beginComputePass({label: '3'}); |
| let buffer8 = device0.createBuffer({size: 17282, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let textureView17 = texture15.createView({}); |
| let computePassEncoder14 = commandEncoder13.beginComputePass({label: '4'}); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| adapter1.label = '\u1707\u0886\u{1f838}\u02fd\u039f'; |
| } catch {} |
| try { |
| device0.label = '\ufae5\u00d2\u7437\u{1f85c}'; |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 32, resource: {buffer: buffer3, offset: 256}}, {binding: 165, resource: textureView1}], |
| }); |
| let buffer9 = device0.createBuffer({ |
| size: 1196, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder15 = device0.createCommandEncoder(); |
| let computePassEncoder15 = commandEncoder15.beginComputePass({label: '5'}); |
| try { |
| device0.queue.writeBuffer(buffer2, 2992, new BigUint64Array(9733), 2767, 100); |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 32, resource: {buffer: buffer2, offset: 256}}, {binding: 165, resource: textureView0}], |
| }); |
| let sampler7 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 74.41}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup2); |
| } catch {} |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| document.body.prepend(canvas0); |
| try { |
| globalThis.someLabel = sampler5.label; |
| } catch {} |
| let buffer10 = device0.createBuffer({ |
| size: 3761, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let computePassEncoder16 = commandEncoder16.beginComputePass({label: '6'}); |
| try { |
| buffer6.unmap(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 32, resource: {buffer: buffer3, offset: 512}}, {binding: 165, resource: textureView1}], |
| }); |
| let buffer11 = device0.createBuffer({size: 14394, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({ |
| size: [8, 8, 22], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder17 = commandEncoder17.beginComputePass({label: '7'}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| buffer6.label = '\u{1fecb}\ue19b\ubf59\ufa0f\u2bce\u0e96\u{1fbcb}\u{1fd74}\u0b53\u7d1f'; |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 176, resource: {buffer: buffer2, offset: 1024}}, |
| {binding: 30, resource: textureView3}, |
| {binding: 138, resource: textureView11}, |
| {binding: 237, resource: textureView8}, |
| {binding: 473, resource: sampler7}, |
| ], |
| }); |
| let buffer12 = device0.createBuffer({size: 6330, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder18 = device0.createCommandEncoder(); |
| let computePassEncoder18 = commandEncoder18.beginComputePass({label: '8'}); |
| let sampler8 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 1, |
| }); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup2, new Uint32Array(295), 14, 0); |
| } catch {} |
| let img0 = await imageWithData(13, 60, '#10101010', '#20202020'); |
| let buffer13 = device0.createBuffer({ |
| label: '\u08d8\u0539\ubd49\u0c08\ub241', |
| size: 18019, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let textureView18 = texture10.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| document.body.append(img0); |
| let imageData1 = new ImageData(24, 132); |
| let texture17 = device0.createTexture({ |
| size: [54, 15, 106], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r8sint'], |
| }); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let textureView19 = texture15.createView({dimension: '1d'}); |
| let sampler9 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 95.68, |
| compare: 'equal', |
| maxAnisotropy: 1, |
| }); |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'gamma28curve'} }); |
| let texture18 = device0.createTexture({ |
| size: [432, 120, 2], |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView20 = texture18.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup3); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(canvas0); |
| let buffer14 = device0.createBuffer({ |
| size: 12332, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, |
| }); |
| let textureView21 = texture8.createView({dimension: '2d'}); |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| struct VertexOutput0 { |
| @location(4) @interpolate(flat, sample) f0: vec4u, |
| @location(5) f1: u32, |
| @builtin(position) f2: vec4f, |
| } |
| |
| var<workgroup> vw2: vec4u; |
| |
| fn fn0() -> mat3x2h { |
| var out: mat3x2h; |
| var vf0: f16 = override1; |
| vf0 = vec4h(unpack4x8unorm(u32(unconst_u32(31))))[2]; |
| var vf1: f32 = override0; |
| var vf2: f32 = determinant(mat3x3f()); |
| let vf3: vec3f = pow(vec3f(unconst_f32(0.2374), unconst_f32(0.1532), unconst_f32(0.3473)), vec3f(unconst_f32(0.02667), unconst_f32(0.01867), unconst_f32(-0.1301))); |
| var vf4: vec3f = inverseSqrt(vec3f(unconst_f32(0.1464), unconst_f32(0.1135), unconst_f32(0.02580))); |
| return out; |
| _ = override0; |
| _ = override1; |
| } |
| |
| override override1: f16 = 6329.0; |
| |
| var<workgroup> vw0: array<atomic<u32>, 1>; |
| |
| var<private> vp0 = modf(f32(0.02298)); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| override override2 = true; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw3: atomic<i32>; |
| |
| var<workgroup> vw1: atomic<u32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexOutput1 { |
| @builtin(position) f3: vec4f, |
| } |
| |
| @id(30730) override override0 = 0.1647; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T0 { |
| @align(256) @size(256) f0: mat3x2h, |
| @size(512) f1: mat2x2f, |
| @align(32) @size(2560) f2: array<array<atomic<i32>, 128>>, |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput0 { |
| var out: VertexOutput0; |
| out.f1 += bitcast<u32>(vp0.whole); |
| vp0.fract = f32(determinant(mat3x3h(unconst_f16(-18482.5), unconst_f16(4360.1), unconst_f16(-23.35), unconst_f16(4838.0), unconst_f16(36054.3), unconst_f16(6093.2), unconst_f16(11974.1), unconst_f16(-737.0), unconst_f16(6422.1)))); |
| out.f1 = bitcast<u32>(cosh(vec2h(unconst_f16(11129.8), unconst_f16(9042.5)))); |
| let vf5: vec3h = cross(vec3h(unconst_f16(14639.0), unconst_f16(27385.8), unconst_f16(10796.0)), vec3h(f16(pack2x16float(vec2f(unconst_f32(0.01911), unconst_f32(-0.09891)))))); |
| vp0 = modf(f32(fma(f16(unconst_f16(-8819.0)), f16(unconst_f16(6819.2)), min(f16(unconst_f16(27334.1)), f16(unconst_f16(7938.7)))))); |
| out.f2 -= vec4f(f32(override2)); |
| out.f2 = vec4f(f32(fma(f16(unconst_f16(34516.8)), f16(unconst_f16(21100.0)), f16(unconst_f16(2049.2))))); |
| out.f0 = vec4u(sinh(vec2h(unconst_f16(11020.8), unconst_f16(-4239.3))).yxyy); |
| out.f0 <<= unpack4xU8(pack2x16float(vec2f(unconst_f32(0.7654), unconst_f32(0.06718)))); |
| let vf6: vec2h = refract(vec2h(unconst_f16(47337.3), unconst_f16(3075.6)), vec2h(unconst_f16(6266.1), unconst_f16(6823.0)), fma(f16(unconst_f16(2224.4)), f16(unconst_f16(25479.9)), f16(unconst_f16(3751.8)))); |
| out.f0 = bitcast<vec4u>(firstTrailingBit(vec3i(unconst_i32(45), unconst_i32(-157), unconst_i32(457))).zxzx); |
| vp0 = modf(vp0.fract); |
| out.f2 = vec4f(f32(override1)); |
| out.f1 = pack2x16unorm(unpack2x16unorm(u32(unconst_u32(116)))); |
| return out; |
| _ = override2; |
| _ = override1; |
| } |
| |
| @vertex |
| fn vertex1(@location(2) a0: vec2i, @location(13) a1: i32, @location(6) a2: vec2h) -> VertexOutput1 { |
| var out: VertexOutput1; |
| var vf7 = fn0(); |
| let vf8: f16 = vf7[u32(unconst_u32(45))][u32(dot4I8Packed(u32(unconst_u32(194)), u32(unconst_u32(45))))]; |
| var vf9 = fn0(); |
| out.f3 = vec4f(vf9[u32(unconst_u32(137))].ggrg); |
| var vf10: f16 = exp2(f16(unconst_f16(8953.8))); |
| fn0(); |
| out = VertexOutput1(vec4f(override0)); |
| var vf11: f16 = vf9[u32(firstLeadingBit(i32(unconst_i32(189))))][u32(unconst_u32(223))]; |
| vf9 += mat3x2h(f16(firstLeadingBit(firstLeadingBit(i32(unconst_i32(40))))), f16(firstLeadingBit(firstLeadingBit(i32(unconst_i32(40))))), f16(firstLeadingBit(firstLeadingBit(i32(unconst_i32(40))))), f16(firstLeadingBit(firstLeadingBit(i32(unconst_i32(40))))), f16(firstLeadingBit(firstLeadingBit(i32(unconst_i32(40))))), f16(firstLeadingBit(firstLeadingBit(i32(unconst_i32(40)))))); |
| let ptr0: ptr<function, f16> = &vf10; |
| fn0(); |
| out.f3 -= vec4f(vf7[u32(unconst_u32(705))].grrr); |
| return out; |
| _ = override1; |
| _ = override0; |
| }`, |
| }); |
| let commandEncoder19 = device0.createCommandEncoder(); |
| let texture19 = device0.createTexture({ |
| size: [54], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView22 = texture5.createView({dimension: '1d', baseArrayLayer: 0}); |
| let sampler10 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer17 = device0.createBuffer({size: 2187, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let textureView23 = texture4.createView({arrayLayerCount: 1}); |
| let texture20 = device0.createTexture({ |
| size: [8, 8, 22], |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView24 = texture15.createView({}); |
| let computePassEncoder19 = commandEncoder19.beginComputePass({label: '9'}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(2345), 367, 0); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let sampler11 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 33.08, |
| lodMaxClamp: 42.85, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(1268), 74, 0); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToBuffer(buffer12, 2932, buffer13, 444, 208); |
| } catch {} |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let computePassEncoder20 = commandEncoder21.beginComputePass({label: '10'}); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1074 */ |
| offset: 1074, |
| buffer: buffer6, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 64, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let imageData2 = new ImageData(24, 96); |
| let computePassEncoder21 = commandEncoder20.beginComputePass({label: '11'}); |
| let sampler12 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.03, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup2, new Uint32Array(1256), 36, 0); |
| } catch {} |
| document.body.append(canvas1); |
| let imageData3 = new ImageData(16, 28); |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let textureView25 = texture3.createView({arrayLayerCount: 1}); |
| let computePassEncoder22 = commandEncoder22.beginComputePass({label: '12'}); |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'linear'} }); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 473, resource: sampler6}, |
| {binding: 30, resource: textureView3}, |
| {binding: 176, resource: {buffer: buffer10, offset: 0, size: 308}}, |
| {binding: 237, resource: textureView8}, |
| {binding: 138, resource: textureView21}, |
| ], |
| }); |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let textureView26 = texture19.createView({mipLevelCount: 1}); |
| let sampler13 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 92.23, |
| }); |
| let texture21 = device0.createTexture({ |
| size: [432, 120, 3], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(9).fill(246), /* required buffer size: 9 */ |
| {offset: 9, rowsPerImage: 0}, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext1 = canvas1.getContext('webgpu'); |
| await gc(); |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 961}); |
| let texture22 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| mipLevelCount: 3, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView27 = texture7.createView({}); |
| let computePassEncoder23 = commandEncoder23.beginComputePass({label: '13'}); |
| try { |
| commandEncoder24.copyTextureToBuffer({ |
| texture: texture10, |
| mipLevel: 1, |
| origin: {x: 7, y: 1, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1192 */ |
| offset: 1192, |
| bytesPerRow: 11776, |
| buffer: buffer11, |
| }, {width: 11, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 23, resource: textureView7}]}); |
| let buffer18 = device0.createBuffer({ |
| size: 9114, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer1, 564, 284); |
| } catch {} |
| let texture23 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 671}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let computePassEncoder24 = commandEncoder25.beginComputePass({label: '14'}); |
| let sampler14 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 85.68, |
| maxAnisotropy: 14, |
| }); |
| try { |
| commandEncoder24.insertDebugMarker('\u40a6'); |
| } catch {} |
| let computePassEncoder25 = commandEncoder24.beginComputePass({label: '14'}); |
| let sampler15 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'nearest', maxAnisotropy: 1}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 4588, new Int16Array(12884), 4637, 224); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(videoFrame0); |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 32, resource: {buffer: buffer18, offset: 768, size: 656}}, |
| {binding: 165, resource: textureView0}, |
| ], |
| }); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let texture24 = device0.createTexture({ |
| size: [108, 30, 2], |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView28 = texture9.createView({}); |
| let bindGroup11 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 23, resource: textureView7}]}); |
| let texture25 = device0.createTexture({size: [108, 30, 2], mipLevelCount: 1, format: 'r8sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder22.setBindGroup(3, bindGroup3, new Uint32Array(1802), 424, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'smpteSt4281'} }); |
| let texture26 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let textureView29 = texture19.createView({baseArrayLayer: 0}); |
| let computePassEncoder26 = commandEncoder26.beginComputePass({label: '15'}); |
| let videoFrame4 = videoFrame2.clone(); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup9); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 30, resource: textureView9}, |
| {binding: 176, resource: {buffer: buffer3, offset: 256}}, |
| {binding: 473, resource: sampler6}, |
| {binding: 237, resource: textureView15}, |
| {binding: 138, resource: textureView11}, |
| ], |
| }); |
| let buffer19 = device0.createBuffer({ |
| size: 2578, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.90, |
| maxAnisotropy: 11, |
| }); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| document.body.prepend(canvas1); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| document.body.prepend(canvas1); |
| let imageData4 = new ImageData(8, 16); |
| let buffer20 = device0.createBuffer({ |
| size: 9881, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 1332}); |
| let computePassEncoder27 = commandEncoder27.beginComputePass({label: '16'}); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup2); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| fn fn1() -> VertexOutput2 { |
| var out: VertexOutput2; |
| var vf19: u32 = pack4x8snorm(vec4f(unconst_f32(0.06026), unconst_f32(0.03551), unconst_f32(0.1696), unconst_f32(0.1234))); |
| var vf20: vec2f = radians(vec2f(unconst_f32(0.1542), unconst_f32(0.04247))); |
| let vf21: vec2h = smoothstep(vec2h(unconst_f16(28381.0), unconst_f16(-8629.0)), vec2h(unconst_f16(17154.8), unconst_f16(13965.7)), vec2h(unconst_f16(-661.7), unconst_f16(31656.8))); |
| var vf22: mat4x2h = transpose(mat2x4h()); |
| return out; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn fn0(a0: ptr<storage, mat2x3f, read_write>) -> array<array<mat2x2h, 1>, 1> { |
| var out: array<array<mat2x2h, 1>, 1>; |
| var vf12: vec3f = log2(vec3f(unconst_f32(0.3003), unconst_f32(0.4018), unconst_f32(0.06239))); |
| vp1 = modf(vec3f(asin(vec4h(unconst_f16(22317.7), unconst_f16(4996.3), unconst_f16(2276.8), unconst_f16(3339.8))).zxw)); |
| vp1 = modf(vec3f(f32(smoothstep(f16(unconst_f16(22527.7)), f16(unconst_f16(10440.1)), f16(unconst_f16(6122.0)))))); |
| var vf13: vec2h = ceil(vec2h(unconst_f16(7881.2), unconst_f16(8788.7))); |
| (*a0) = mat2x3f(f32(smoothstep(f16(unconst_f16(3786.4)), f16(unconst_f16(26666.0)), f16(unconst_f16(18870.4)))), f32(smoothstep(f16(unconst_f16(3786.4)), f16(unconst_f16(26666.0)), f16(unconst_f16(18870.4)))), f32(smoothstep(f16(unconst_f16(3786.4)), f16(unconst_f16(26666.0)), f16(unconst_f16(18870.4)))), f32(smoothstep(f16(unconst_f16(3786.4)), f16(unconst_f16(26666.0)), f16(unconst_f16(18870.4)))), f32(smoothstep(f16(unconst_f16(3786.4)), f16(unconst_f16(26666.0)), f16(unconst_f16(18870.4)))), f32(smoothstep(f16(unconst_f16(3786.4)), f16(unconst_f16(26666.0)), f16(unconst_f16(18870.4))))); |
| let ptr1: ptr<function, vec2h> = &vf13; |
| let vf14: f16 = override5; |
| let vf15: f32 = override3; |
| var vf16: vec2h = exp(vec2h(unconst_f16(13342.5), unconst_f16(22131.1))); |
| var vf17: f16 = asinh(f16(unconst_f16(9146.2))); |
| let vf18: f16 = vf14; |
| return out; |
| _ = override3; |
| _ = override5; |
| } |
| |
| override override4: u32; |
| |
| @group(0) @binding(176) var<storage, read_write> buffer21: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, 3>, 1>, 1>>; |
| |
| var<private> vp1 = modf(vec3f(0.1172, 0.1601, 0.05554)); |
| |
| struct VertexOutput2 { |
| @location(9) @interpolate(flat) f4: vec2i, |
| @location(0) @interpolate(perspective, sample) f5: vec2h, |
| @location(8) f6: vec4u, |
| @location(6) @interpolate(perspective, centroid) f7: vec4h, |
| @builtin(position) f8: vec4f, |
| @location(14) f9: f16, |
| } |
| |
| var<workgroup> vw4: atomic<u32>; |
| |
| fn fn2() -> array<VertexOutput2, 1> { |
| var out: array<VertexOutput2, 1>; |
| var vf23 = fn1(); |
| let ptr2: ptr<storage, array<f16, 1>, read_write> = &(*&buffer21)[u32(unconst_u32(38))][0][0][u32(unconst_u32(377))][0][2][0][u32(unconst_u32(26))]; |
| out[u32(unconst_u32(164))] = VertexOutput2(vec2i(i32((*&buffer21)[u32(unconst_u32(173))][u32(unconst_u32(212))][u32(unconst_u32(133))][u32(unconst_u32(34))][0][2][0][0][0])), vec2h((*&buffer21)[u32(unconst_u32(173))][u32(unconst_u32(212))][u32(unconst_u32(133))][u32(unconst_u32(34))][0][2][0][0][0]), vec4u(u32((*&buffer21)[u32(unconst_u32(173))][u32(unconst_u32(212))][u32(unconst_u32(133))][u32(unconst_u32(34))][0][2][0][0][0])), vec4h((*&buffer21)[u32(unconst_u32(173))][u32(unconst_u32(212))][u32(unconst_u32(133))][u32(unconst_u32(34))][0][2][0][0][0]), vec4f(f32((*&buffer21)[u32(unconst_u32(173))][u32(unconst_u32(212))][u32(unconst_u32(133))][u32(unconst_u32(34))][0][2][0][0][0])), (*&buffer21)[u32(unconst_u32(173))][u32(unconst_u32(212))][u32(unconst_u32(133))][u32(unconst_u32(34))][0][2][0][0][0]); |
| var vf24 = fn1(); |
| let ptr3: ptr<storage, f16, read_write> = &(*&buffer21)[u32(unconst_u32(170))][u32(unconst_u32(93))][0][2][u32(unconst_u32(33))][2][0][0][0]; |
| vf24 = VertexOutput2(vec2i(i32(buffer21[arrayLength(&buffer21)][u32(unconst_u32(231))][0][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0][0])), vec2h(buffer21[arrayLength(&buffer21)][u32(unconst_u32(231))][0][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0][0]), vec4u(u32(buffer21[arrayLength(&buffer21)][u32(unconst_u32(231))][0][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0][0])), vec4h(buffer21[arrayLength(&buffer21)][u32(unconst_u32(231))][0][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0][0]), vec4f(f32(buffer21[arrayLength(&buffer21)][u32(unconst_u32(231))][0][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0][0])), buffer21[arrayLength(&buffer21)][u32(unconst_u32(231))][0][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0][0]); |
| buffer22[u32(unconst_u32(463))][u32(unconst_u32(7))][u32(unconst_u32(327))][u32(unconst_u32(307))][u32(unconst_u32(51))][u32(unconst_u32(3))][u32((*&buffer21)[arrayLength(&(*&buffer21))][u32(unconst_u32(291))][0][u32(unconst_u32(84))][0][2][0][0][0])] -= buffer21[u32(unconst_u32(5))][0][u32(unconst_u32(34))][u32(unconst_u32(55))][u32(unconst_u32(121))][2][0][u32(unconst_u32(8))][0]; |
| buffer22[u32(unconst_u32(41))][u32(unconst_u32(297))][u32(unconst_u32(2))][u32(unconst_u32(200))][u32(unconst_u32(430))][u32(unconst_u32(119))][u32(unconst_u32(11))] -= buffer21[arrayLength(&buffer21)][0][u32(unconst_u32(41))][2][u32(unconst_u32(129))][u32((*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(207))][2][0][u32(unconst_u32(66))][0][0][0])][0][0][0]; |
| let ptr4: ptr<storage, array<array<array<f16, 1>, 3>, 1>, read_write> = &(*&buffer22)[u32(buffer22[u32(unconst_u32(16))][0][0][2][u32(unconst_u32(20))][u32(unconst_u32(40))][0])][u32(unconst_u32(221))][u32(unconst_u32(257))][2]; |
| vf24 = VertexOutput2(vec2i(i32((*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(26))][2][u32(unconst_u32(250))][2][0][0][0])), vec2h((*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(26))][2][u32(unconst_u32(250))][2][0][0][0]), vec4u(u32((*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(26))][2][u32(unconst_u32(250))][2][0][0][0])), vec4h((*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(26))][2][u32(unconst_u32(250))][2][0][0][0]), vec4f(f32((*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(26))][2][u32(unconst_u32(250))][2][0][0][0])), (*&buffer21)[arrayLength(&(*&buffer21))][0][u32(unconst_u32(26))][2][u32(unconst_u32(250))][2][0][0][0]); |
| let ptr5: ptr<storage, array<array<f16, 1>, 3>, read_write> = &buffer22[u32((*&buffer21)[u32(unconst_u32(177))][u32(unconst_u32(116))][0][u32(buffer22[0][u32(unconst_u32(64))][u32(unconst_u32(378))][u32(unconst_u32(136))][u32((*&buffer21)[u32(unconst_u32(308))][0][0][2][u32(unconst_u32(180))][2][0][u32(unconst_u32(394))][0])][2][0])][0][2][u32(unconst_u32(413))][u32(unconst_u32(205))][u32(unconst_u32(50))])][0][u32(buffer21[arrayLength(&buffer21)][u32(unconst_u32(31))][0][2][u32(unconst_u32(1000))][u32(unconst_u32(26))][u32((*&buffer21)[u32(unconst_u32(330))][0][u32(unconst_u32(55))][u32(unconst_u32(248))][u32(unconst_u32(83))][u32(buffer22[u32(unconst_u32(188))][u32(buffer21[arrayLength(&buffer21)][0][u32(unconst_u32(53))][u32(unconst_u32(22))][u32(unconst_u32(145))][u32(unconst_u32(627))][u32(unconst_u32(234))][u32(unconst_u32(102))][0])][u32(unconst_u32(170))][2][u32(unconst_u32(48))][2][0])][u32(unconst_u32(0))][0][u32(unconst_u32(1))])][0][0])][2][u32(unconst_u32(250))]; |
| let ptr6: ptr<storage, array<f16, 1>, read_write> = &buffer21[u32(unconst_u32(1000))][u32(unconst_u32(36))][0][u32(unconst_u32(358))][0][2][0][u32(unconst_u32(25))]; |
| vf24 = VertexOutput2(vec2i(i32((*&buffer21)[u32(buffer21[u32(unconst_u32(54))][u32(unconst_u32(260))][u32((*&buffer21)[u32(unconst_u32(357))][u32(unconst_u32(255))][u32(unconst_u32(256))][2][u32(unconst_u32(183))][u32(unconst_u32(118))][u32(unconst_u32(636))][u32(buffer21[arrayLength(&buffer21)][0][0][2][u32(unconst_u32(898))][2][0][0][0])][0])][u32(unconst_u32(330))][0][u32(unconst_u32(0))][0][u32(unconst_u32(222))][u32(unconst_u32(61))])][0][u32(unconst_u32(128))][u32(unconst_u32(69))][u32(unconst_u32(113))][2][0][0][0])), vec2h((*&buffer21)[u32(buffer21[u32(unconst_u32(54))][u32(unconst_u32(260))][u32((*&buffer21)[u32(unconst_u32(357))][u32(unconst_u32(255))][u32(unconst_u32(256))][2][u32(unconst_u32(183))][u32(unconst_u32(118))][u32(unconst_u32(636))][u32(buffer21[arrayLength(&buffer21)][0][0][2][u32(unconst_u32(898))][2][0][0][0])][0])][u32(unconst_u32(330))][0][u32(unconst_u32(0))][0][u32(unconst_u32(222))][u32(unconst_u32(61))])][0][u32(unconst_u32(128))][u32(unconst_u32(69))][u32(unconst_u32(113))][2][0][0][0]), vec4u(u32((*&buffer21)[u32(buffer21[u32(unconst_u32(54))][u32(unconst_u32(260))][u32((*&buffer21)[u32(unconst_u32(357))][u32(unconst_u32(255))][u32(unconst_u32(256))][2][u32(unconst_u32(183))][u32(unconst_u32(118))][u32(unconst_u32(636))][u32(buffer21[arrayLength(&buffer21)][0][0][2][u32(unconst_u32(898))][2][0][0][0])][0])][u32(unconst_u32(330))][0][u32(unconst_u32(0))][0][u32(unconst_u32(222))][u32(unconst_u32(61))])][0][u32(unconst_u32(128))][u32(unconst_u32(69))][u32(unconst_u32(113))][2][0][0][0])), vec4h((*&buffer21)[u32(buffer21[u32(unconst_u32(54))][u32(unconst_u32(260))][u32((*&buffer21)[u32(unconst_u32(357))][u32(unconst_u32(255))][u32(unconst_u32(256))][2][u32(unconst_u32(183))][u32(unconst_u32(118))][u32(unconst_u32(636))][u32(buffer21[arrayLength(&buffer21)][0][0][2][u32(unconst_u32(898))][2][0][0][0])][0])][u32(unconst_u32(330))][0][u32(unconst_u32(0))][0][u32(unconst_u32(222))][u32(unconst_u32(61))])][0][u32(unconst_u32(128))][u32(unconst_u32(69))][u32(unconst_u32(113))][2][0][0][0]), vec4f(f32((*&buffer21)[u32(buffer21[u32(unconst_u32(54))][u32(unconst_u32(260))][u32((*&buffer21)[u32(unconst_u32(357))][u32(unconst_u32(255))][u32(unconst_u32(256))][2][u32(unconst_u32(183))][u32(unconst_u32(118))][u32(unconst_u32(636))][u32(buffer21[arrayLength(&buffer21)][0][0][2][u32(unconst_u32(898))][2][0][0][0])][0])][u32(unconst_u32(330))][0][u32(unconst_u32(0))][0][u32(unconst_u32(222))][u32(unconst_u32(61))])][0][u32(unconst_u32(128))][u32(unconst_u32(69))][u32(unconst_u32(113))][2][0][0][0])), (*&buffer21)[u32(buffer21[u32(unconst_u32(54))][u32(unconst_u32(260))][u32((*&buffer21)[u32(unconst_u32(357))][u32(unconst_u32(255))][u32(unconst_u32(256))][2][u32(unconst_u32(183))][u32(unconst_u32(118))][u32(unconst_u32(636))][u32(buffer21[arrayLength(&buffer21)][0][0][2][u32(unconst_u32(898))][2][0][0][0])][0])][u32(unconst_u32(330))][0][u32(unconst_u32(0))][0][u32(unconst_u32(222))][u32(unconst_u32(61))])][0][u32(unconst_u32(128))][u32(unconst_u32(69))][u32(unconst_u32(113))][2][0][0][0]); |
| let ptr7: ptr<storage, array<f16, 1>, read_write> = &(*&buffer22)[0][0][0][2][u32(unconst_u32(47))][u32(unconst_u32(307))]; |
| let ptr8: ptr<storage, f16, read_write> = &buffer21[arrayLength(&buffer21)][0][0][u32(unconst_u32(183))][0][2][u32(unconst_u32(376))][u32(unconst_u32(31))][u32(unconst_u32(45))]; |
| return out; |
| _ = buffer21; |
| _ = buffer22; |
| } |
| |
| var<workgroup> vw5: atomic<u32>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw7: T0; |
| |
| @group(0) @binding(30) var st4: texture_storage_2d_array<r32sint, read_write>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| @size(20) f0: atomic<i32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(1) @binding(176) var<storage, read_write> buffer22: array<array<array<array<array<array<array<f16, 1>, 3>, 1>, 3>, 1>, 1>, 1>; |
| |
| override override3: f32; |
| |
| override override5: f16 = 1750.4; |
| |
| var<workgroup> vw6: atomic<u32>; |
| |
| @vertex |
| fn vertex2(@location(12) a0: vec4f, @location(10) @interpolate(flat, center) a1: vec2f) -> VertexOutput2 { |
| var out: VertexOutput2; |
| out.f4 |= vec2i(i32(max(f16(unconst_f16(16086.8)), f16(unconst_f16(454.6))))); |
| out = VertexOutput2(vec2i(i32(override5)), vec2h(override5), vec4u(u32(override5)), vec4h(override5), vec4f(f32(override5)), override5); |
| let vf25: f32 = override3; |
| fn1(); |
| var vf26: f32 = override3; |
| out.f4 = vec2i(a0.rr); |
| out.f9 = f16(vf26); |
| let vf27: f16 = override5; |
| out.f5 += vec2h(vf27); |
| out.f8 += vec4f(vf25); |
| out.f9 = f16(distance(f32(unconst_f32(0.01306)), f32(unconst_f32(0.05123)))); |
| out.f9 *= f16(max(u32(unconst_u32(25)), u32(unconst_u32(97)))); |
| fn1(); |
| out.f7 = vec4h(vp1.whole.brgb); |
| fn1(); |
| var vf28: vec4f = degrees(vec4f(unconst_f32(0.1495), unconst_f32(0.4155), unconst_f32(0.04995), unconst_f32(0.01255))); |
| out.f5 *= bitcast<vec2h>(override4); |
| var vf29: vec2f = a1; |
| vf28 = vec4f(f32(override4)); |
| vp1 = modf(degrees(vec4f(unconst_f32(0.1522), unconst_f32(-0.1716), unconst_f32(0.1763), unconst_f32(0.06170))).ggb); |
| let vf30: vec4f = degrees(vec4f(unconst_f32(0.06329), unconst_f32(0.1390), unconst_f32(0.4450), unconst_f32(0.1006))); |
| vf28 = vec4f(sqrt(vec4h(unconst_f16(7175.0), unconst_f16(17757.3), unconst_f16(1052.3), unconst_f16(1806.3)))); |
| return out; |
| _ = override5; |
| _ = override3; |
| _ = override4; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute0(@builtin(workgroup_id) a0: vec3u) { |
| var vf31 = fn1(); |
| vf31 = VertexOutput2(vec2i(i32((*&buffer21)[u32(unconst_u32(72))][0][0][u32(unconst_u32(294))][u32(unconst_u32(276))][2][0][u32(unconst_u32(145))][u32(unconst_u32(115))])), vec2h((*&buffer21)[u32(unconst_u32(72))][0][0][u32(unconst_u32(294))][u32(unconst_u32(276))][2][0][u32(unconst_u32(145))][u32(unconst_u32(115))]), vec4u(u32((*&buffer21)[u32(unconst_u32(72))][0][0][u32(unconst_u32(294))][u32(unconst_u32(276))][2][0][u32(unconst_u32(145))][u32(unconst_u32(115))])), vec4h((*&buffer21)[u32(unconst_u32(72))][0][0][u32(unconst_u32(294))][u32(unconst_u32(276))][2][0][u32(unconst_u32(145))][u32(unconst_u32(115))]), vec4f(f32((*&buffer21)[u32(unconst_u32(72))][0][0][u32(unconst_u32(294))][u32(unconst_u32(276))][2][0][u32(unconst_u32(145))][u32(unconst_u32(115))])), (*&buffer21)[u32(unconst_u32(72))][0][0][u32(unconst_u32(294))][u32(unconst_u32(276))][2][0][u32(unconst_u32(145))][u32(unconst_u32(115))]); |
| atomicOr(&vw7.f0, i32(unconst_i32(103))); |
| textureStore(st4, vec2i(unconst_i32(173), unconst_i32(-2)), i32(unconst_i32(6)), vec4i(vec4i(unconst_i32(77), unconst_i32(11), unconst_i32(93), unconst_i32(-165)))); |
| atomicOr(&vw6, u32(unconst_u32(6))); |
| let ptr9: ptr<storage, f16, read_write> = &buffer22[u32(unconst_u32(22))][u32(unconst_u32(155))][u32((*&buffer22)[0][0][u32(unconst_u32(54))][2][0][2][0])][2][0][u32(unconst_u32(55))][0]; |
| atomicStore(&vw4, u32(unconst_u32(7))); |
| _ = buffer22; |
| _ = buffer21; |
| _ = st4; |
| }`, |
| }); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let textureView30 = texture4.createView({dimension: '2d'}); |
| let computePassEncoder28 = commandEncoder28.beginComputePass({label: '17'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 3, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(30).fill(172), /* required buffer size: 30 */ |
| {offset: 30, bytesPerRow: 60}, {width: 36, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer23 = device0.createBuffer({ |
| size: 8209, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup9); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| @id(3639) override override9: u32 = 169; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(39313) override override6: f32; |
| |
| @group(1) @binding(176) var<storage, read_write> buffer25: array<f16, 9>; |
| |
| var<workgroup> vw8: array<atomic<u32>, 25>; |
| |
| var<workgroup> vw9: T2; |
| |
| fn fn1() -> mat3x2f { |
| var out: mat3x2f; |
| let vf44: f16 = override8; |
| out = mat3x2f(faceForward(vec4f(unconst_f32(0.02208), unconst_f32(0.05099), unconst_f32(0.1718), unconst_f32(0.7557)), vec4f(unconst_f32(0.02071), unconst_f32(0.01709), unconst_f32(0.02877), unconst_f32(0.1264)), vec4f(unconst_f32(0.1122), unconst_f32(0.01308), unconst_f32(0.4596), unconst_f32(0.6711))).ga, faceForward(vec4f(unconst_f32(0.02208), unconst_f32(0.05099), unconst_f32(0.1718), unconst_f32(0.7557)), vec4f(unconst_f32(0.02071), unconst_f32(0.01709), unconst_f32(0.02877), unconst_f32(0.1264)), vec4f(unconst_f32(0.1122), unconst_f32(0.01308), unconst_f32(0.4596), unconst_f32(0.6711))).zy, faceForward(vec4f(unconst_f32(0.02208), unconst_f32(0.05099), unconst_f32(0.1718), unconst_f32(0.7557)), vec4f(unconst_f32(0.02071), unconst_f32(0.01709), unconst_f32(0.02877), unconst_f32(0.1264)), vec4f(unconst_f32(0.1122), unconst_f32(0.01308), unconst_f32(0.4596), unconst_f32(0.6711))).aa); |
| var vf45: vec4f = faceForward(vec4f(unconst_f32(0.04739), unconst_f32(0.1409), unconst_f32(0.02161), unconst_f32(0.01353)), vec4f(unconst_f32(0.04838), unconst_f32(0.00169), unconst_f32(0.2759), unconst_f32(0.02239)), vec4f(unconst_f32(0.01871), unconst_f32(-0.01171), unconst_f32(0.1286), unconst_f32(0.3579))); |
| out = mat3x2f(vf45.yx, vf45.rr, vf45.gg); |
| vf45 *= unpack4x8snorm(override9); |
| var vf46: vec3f = cross(vec3f(unconst_f32(0.4744), unconst_f32(0.1151), unconst_f32(0.5253)), vec3f(unconst_f32(0.1596), unconst_f32(0.05983), unconst_f32(0.09908))); |
| let vf47: f16 = inverseSqrt(f16(unconst_f16(806.0))); |
| return out; |
| _ = override8; |
| _ = override9; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(1) @binding(237) var st10: texture_storage_1d<r32float, read_write>; |
| |
| @id(1579) override override8: f16; |
| |
| var<workgroup> vw10: vec2f; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn fn0() -> vec2h { |
| var out: vec2h; |
| let vf32: u32 = firstTrailingBit(u32(unconst_u32(110))); |
| out += vec2h(dot(vec2h(unconst_f16(275.9), unconst_f16(-15561.4)), vec2h(unconst_f16(-4259.4), unconst_f16(332.9)))); |
| let vf33: u32 = pack4xU8(vec4u(unconst_u32(127), unconst_u32(80), unconst_u32(80), unconst_u32(285))); |
| let vf34: vec2h = sqrt(vec2h(unconst_f16(16277.4), unconst_f16(5201.8))); |
| out = bitcast<vec2h>(vf32); |
| let vf35: u32 = override9; |
| let vf36: f16 = dot(vec2h(unconst_f16(8362.3), unconst_f16(2148.1)), vec2h(unconst_f16(1228.1), unconst_f16(6082.3))); |
| var vf37: f32 = override7; |
| vf37 = vf37; |
| var vf38: f16 = vf34[u32(unconst_u32(246))]; |
| let vf39: f32 = override7; |
| let vf40: vec2h = vf34; |
| vf38 += f16(override9); |
| vf38 *= cosh(vec2h(unconst_f16(11062.9), unconst_f16(8307.6)))[1]; |
| let vf41: f32 = vf39; |
| var vf42: f32 = override7; |
| var vf43: f16 = dot(vec2h(unconst_f16(21015.2), unconst_f16(19485.6)), vec2h(unconst_f16(11947.6), unconst_f16(-1603.7))); |
| return out; |
| _ = override9; |
| _ = override7; |
| } |
| |
| struct T1 { |
| @size(20) f0: array<u32>, |
| } |
| |
| @id(49639) override override7 = -1.000; |
| |
| struct T3 { |
| @size(20) f0: array<u32>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T2 { |
| @size(20) f0: atomic<i32>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw13: vec4i; |
| |
| var<workgroup> vw11: T0; |
| |
| var<workgroup> vw12: FragmentOutput0; |
| |
| @group(0) @binding(176) var<storage, read_write> buffer24: array<array<array<array<f16, 1>, 3>, 3>>; |
| |
| struct T0 { |
| @size(16) f0: array<f32, 1>, |
| f1: array<f16, 1>, |
| } |
| |
| struct FragmentOutput0 { |
| @location(6) f0: vec4u, |
| @location(0) f1: vec2i, |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| buffer25[u32(unconst_u32(384))] = buffer24[u32(unconst_u32(353))][u32(unconst_u32(54))][u32(unconst_u32(74))][u32(unconst_u32(28))]; |
| let ptr10: ptr<storage, f16, read_write> = &buffer24[arrayLength(&buffer24)][u32(unconst_u32(315))][u32(unconst_u32(217))][u32(unconst_u32(331))]; |
| fn1(); |
| out.f1 = vec2i(i32((*&buffer24)[u32(unconst_u32(860))][u32(unconst_u32(22))][u32(unconst_u32(262))][u32(buffer24[textureDimensions(st10)][2][2][u32(buffer24[arrayLength(&buffer24)][u32(unconst_u32(211))][u32(unconst_u32(153))][0])])])); |
| let ptr11: ptr<storage, array<f16, 1>, read_write> = &buffer24[u32(unconst_u32(144))][2][u32(unconst_u32(47))]; |
| fn1(); |
| var vf48 = fn1(); |
| var vf49 = fn1(); |
| out.f1 = vec2i(i32((*&buffer24)[u32(unconst_u32(46))][2][2][0])); |
| let ptr12: ptr<storage, array<f16, 1>, read_write> = &buffer24[arrayLength(&buffer24)][2][u32(unconst_u32(220))]; |
| textureStore(st10, i32(unconst_i32(37)), vec4f(vec4f(unconst_f32(0.07477), unconst_f32(0.08673), unconst_f32(0.02571), unconst_f32(0.00513)))); |
| fn1(); |
| let ptr13: ptr<storage, array<array<f16, 1>, 3>, read_write> = &(*&buffer24)[arrayLength(&(*&buffer24))][2]; |
| return out; |
| _ = override9; |
| _ = override8; |
| _ = buffer24; |
| _ = st10; |
| _ = buffer25; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute1(@builtin(global_invocation_id) a0: vec3u) { |
| let vf50: i32 = vw12.f1[u32(unconst_u32(443))]; |
| vw12.f1 *= vec2i(i32(buffer24[arrayLength(&buffer24)][2][pack2x16float(vw10)][0])); |
| atomicAdd(&vw9.f0, i32(unconst_i32(277))); |
| buffer25[u32(unconst_u32(328))] = (*&buffer24)[arrayLength(&(*&buffer24))][2][2][0]; |
| vw11 = T0(array<f32, 1>(f32(buffer24[arrayLength(&buffer24)][u32(unconst_u32(51))][2][u32(unconst_u32(39))])), array<f16, 1>(buffer24[arrayLength(&buffer24)][u32(unconst_u32(51))][2][u32(unconst_u32(39))])); |
| let ptr14: ptr<workgroup, f16> = &vw11.f1[u32(unconst_u32(262))]; |
| vw10 = vec2f(f32(buffer24[arrayLength(&buffer24)][2][2][0])); |
| buffer24[u32(unconst_u32(314))][u32(buffer24[u32((*&buffer25)[8])][2][2][u32(buffer24[arrayLength(&buffer24)][2][2][0])])][u32(unconst_u32(126))][u32(unconst_u32(87))] = f16((*&vw11).f0[0]); |
| _ = buffer25; |
| _ = buffer24; |
| }`, |
| }); |
| try { |
| buffer9.destroy(); |
| } catch {} |
| let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let buffer26 = device0.createBuffer({size: 696, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture27 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture28 = device0.createTexture({ |
| size: [108], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup11, new Uint32Array(196), 85, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(0); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 70.27, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| document.body.prepend(img0); |
| let autogeneratedBindGroupLayout1 = pipeline0.getBindGroupLayout(1); |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 32, resource: {buffer: buffer18, offset: 1280, size: 624}}, |
| {binding: 165, resource: textureView0}, |
| ], |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup3, new Uint32Array(2610), 2_610, 0); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let texture29 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 679}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture30 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder29 = commandEncoder29.beginComputePass({label: '18'}); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup2, new Uint32Array(169), 41, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup9, new Uint32Array(1439), 1_360, 0); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let buffer27 = device0.createBuffer({size: 37641, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder29.setBindGroup(3, bindGroup13); |
| } catch {} |
| let promise2 = shaderModule0.getCompilationInfo(); |
| try { |
| computePassEncoder26.pushDebugGroup('\u{1f867}'); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 176, resource: {buffer: buffer8, offset: 2560, size: 5464}}, |
| {binding: 237, resource: textureView8}, |
| {binding: 473, resource: sampler15}, |
| {binding: 30, resource: textureView9}, |
| {binding: 138, resource: textureView21}, |
| ], |
| }); |
| let buffer28 = device0.createBuffer({ |
| size: 18223, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let texture31 = device0.createTexture({ |
| size: [108, 30, 236], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder30 = commandEncoder30.beginComputePass({label: '19'}); |
| try { |
| computePassEncoder17.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipeline1 = device0.createComputePipeline({label: 'bbb', layout: 'auto', compute: {module: shaderModule2}}); |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let textureView31 = texture13.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout2 = pipeline1.getBindGroupLayout(1); |
| let buffer29 = device0.createBuffer({size: 7217, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let renderPassEncoder0 = commandEncoder32.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 952.8, g: 181.9, b: -90.56, a: -574.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 133468867, |
| }); |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 97.36, |
| }); |
| try { |
| commandEncoder31.resolveQuerySet(querySet1, 9, 170, buffer27, 11008); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0); |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 237, resource: textureView15}, |
| {binding: 176, resource: {buffer: buffer23, offset: 1792, size: 40}}, |
| {binding: 138, resource: textureView21}, |
| {binding: 473, resource: sampler13}, |
| {binding: 30, resource: textureView23}, |
| ], |
| }); |
| let commandEncoder33 = device0.createCommandEncoder({label: '\u{1f7a8}\u0866\u{1ff43}\u{1f650}\ub6ab\u0be9\u3d4d\u{1fb97}'}); |
| let computePassEncoder31 = commandEncoder33.beginComputePass({label: '20'}); |
| let renderPassEncoder1 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 12, |
| clearValue: { r: -539.1, g: 172.1, b: -156.2, a: 870.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder28.end(); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder26.popDebugGroup(); |
| } catch {} |
| let renderPassEncoder2 = commandEncoder28.beginRenderPass({colorAttachments: [{view: textureView28, depthSlice: 18, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer1, 448, 241); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout4 = pipeline1.getBindGroupLayout(1); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let textureView32 = texture16.createView({baseArrayLayer: 3, arrayLayerCount: 2}); |
| let texture32 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture33 = gpuCanvasContext0.getCurrentTexture(); |
| let sampler19 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat'}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup10, new Uint32Array(5537), 775, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(13, 2, 25, 11); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer1); |
| } catch {} |
| try { |
| commandEncoder34.clearBuffer(buffer13, 2892, 1588); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout5 = pipeline0.getBindGroupLayout(1); |
| let texture34 = device0.createTexture({size: [216, 60, 2], format: 'depth24plus', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| let textureView33 = texture30.createView({}); |
| let sampler20 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 90.04, compare: 'less'}); |
| try { |
| computePassEncoder29.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup13, new Uint32Array(1365), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup14, []); |
| } catch {} |
| try { |
| renderPassEncoder1.setStencilReference(297); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToBuffer({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 40, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 88 widthInBlocks: 88 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 4733 */ |
| offset: 4733, |
| bytesPerRow: 7168, |
| buffer: buffer14, |
| }, {width: 88, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(21).fill(205), /* required buffer size: 21 */ |
| {offset: 21, rowsPerImage: 24}, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpteSt4281', transfer: 'gamma28curve'} }); |
| let commandEncoder35 = device0.createCommandEncoder(); |
| let texture35 = device0.createTexture({ |
| size: {width: 216}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup14, new Uint32Array(826), 93, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer2, 'uint32', 500, 2_297); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [{binding: 110, resource: {buffer: buffer23, offset: 512, size: 1276}}], |
| }); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup13, new Uint32Array(1193), 163, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup11, new Uint32Array(295), 8, 0); |
| } catch {} |
| try { |
| commandEncoder35.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 4841 */ |
| offset: 4841, |
| bytesPerRow: 23040, |
| rowsPerImage: 48, |
| buffer: buffer3, |
| }, { |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder36.resolveQuerySet(querySet1, 556, 41, buffer19, 1024); |
| } catch {} |
| let imageData5 = new ImageData(52, 76); |
| let autogeneratedBindGroupLayout6 = pipeline1.getBindGroupLayout(1); |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 402}); |
| let textureView34 = texture25.createView({arrayLayerCount: 1}); |
| let renderPassEncoder3 = commandEncoder34.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 757.9, g: -797.0, b: -900.0, a: -270.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet2, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer3, 'uint16', 13_560, 952); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| let buffer30 = device0.createBuffer({size: 6643, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let querySet3 = device0.createQuerySet({type: 'occlusion', count: 1455}); |
| let textureView35 = texture16.createView({baseArrayLayer: 2, arrayLayerCount: 1}); |
| let computePassEncoder32 = commandEncoder36.beginComputePass({label: '21'}); |
| let renderPassEncoder4 = commandEncoder35.beginRenderPass({ |
| colorAttachments: [{view: textureView31, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 385412712, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, undefined); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 84, new BigUint64Array(6996), 1034, 224); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout7 = pipeline0.getBindGroupLayout(0); |
| let buffer31 = device0.createBuffer({ |
| size: 752, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let textureView36 = texture29.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup2, new Uint32Array(464), 42, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'display-p3'}); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer32 = device0.createBuffer({ |
| size: 7725, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture36 = gpuCanvasContext1.getCurrentTexture(); |
| let sampler21 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 47.74, lodMaxClamp: 99.72}); |
| try { |
| computePassEncoder23.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer10, 'uint16', 294, 122); |
| } catch {} |
| document.body.append(canvas1); |
| let buffer33 = device0.createBuffer({size: 11155, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let textureView37 = texture24.createView({dimension: '2d'}); |
| let sampler22 = device0.createSampler({addressModeV: 'repeat', lodMinClamp: 54.72, lodMaxClamp: 77.16}); |
| try { |
| computePassEncoder27.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer10, 'uint32', 1_188, 291); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer20, 0, 2_392); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let autogeneratedBindGroupLayout8 = pipeline1.getBindGroupLayout(1); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup8, new Uint32Array(1387), 220, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup2); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 110, resource: {buffer: buffer18, offset: 1024, size: 808}}], |
| }); |
| let texture37 = device0.createTexture({size: [54], mipLevelCount: 1, dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView38 = texture20.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 6}); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup10, new Uint32Array(1643), 207, 0); |
| } catch {} |
| let imageData6 = new ImageData(56, 52); |
| let buffer34 = device0.createBuffer({ |
| size: 3633, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let sampler23 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.19, |
| compare: 'not-equal', |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup15, new Uint32Array(762), 406, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer31, 'uint16', 12, 240); |
| } catch {} |
| let sampler24 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.34, |
| maxAnisotropy: 3, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup14, new Uint32Array(1725), 124, 0); |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 176, resource: {buffer: buffer10, offset: 256, size: 588}}], |
| }); |
| let buffer35 = device0.createBuffer({size: 10685, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder37 = device0.createCommandEncoder({}); |
| let computePassEncoder33 = commandEncoder37.beginComputePass({label: '22'}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup11, new Uint32Array(642), 43, 0); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| let buffer36 = device0.createBuffer({ |
| size: 15547, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView39 = texture20.createView({dimension: 'cube', baseMipLevel: 0, mipLevelCount: 1}); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.63, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup14, new Uint32Array(6066), 947, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setViewport(79.03740968931368, 20.59458476088974, 13.670462720004888, 37.031388198165125, 0.7408286035770237, 0.9480174996841199); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer4, 0, 2_022); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 176, resource: {buffer: buffer10, offset: 0, size: 148}}], |
| }); |
| let commandEncoder38 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: {width: 108}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder34 = commandEncoder38.beginComputePass({label: '23'}); |
| try { |
| computePassEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup13, new Uint32Array(5051), 22, 0); |
| } catch {} |
| let pipeline2 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, constants: {}}}); |
| await gc(); |
| let imageData7 = new ImageData(68, 36); |
| let bindGroup20 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 23, resource: textureView5}]}); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let textureView40 = texture30.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let computePassEncoder35 = commandEncoder39.beginComputePass({label: '24'}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup16, new Uint32Array(266), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -297.7, g: -674.9, b: 11.97, a: -275.6, }); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer10, 'uint32', 120, 573); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(211, 83); |
| let autogeneratedBindGroupLayout9 = pipeline2.getBindGroupLayout(1); |
| let buffer37 = device0.createBuffer({ |
| size: 1396, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let texture39 = device0.createTexture({ |
| size: [54, 15, 2], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture40 = device0.createTexture({ |
| size: [54], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView41 = texture31.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder36 = commandEncoder40.beginComputePass({label: '25'}); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup3, new Uint32Array(2281), 304, 0); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(5, buffer32); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 46, y: 10, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(5).fill(196), /* required buffer size: 5 */ |
| {offset: 5}, {width: 13, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let pipeline3 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {1_579: 0}, |
| targets: [{format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex1', |
| constants: {override1: 0, 30_730: 0}, |
| buffers: [ |
| { |
| arrayStride: 504, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 112, shaderLocation: 2}, |
| {format: 'sint8x4', offset: 56, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 56, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView42 = texture4.createView({dimension: '2d'}); |
| let computePassEncoder37 = commandEncoder41.beginComputePass({label: '26'}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup13, new Uint32Array(815), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup19, new Uint32Array(693), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setStencilReference(680); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 19, y: 11, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(273).fill(90), /* required buffer size: 273 */ |
| {offset: 273, bytesPerRow: 87}, {width: 49, height: 43, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\ub6ba\u9af1\u{1fc01}\u5876\u{1fa7e}\uc285\u{1fc3f}\u{1fef0}\ubdae\u0397'; |
| } catch {} |
| let autogeneratedBindGroupLayout10 = pipeline0.getBindGroupLayout(0); |
| try { |
| computePassEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer3, 'uint32', 192, 1_883); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer32, 2_176, 45); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup13, new Uint32Array(724), 101, 0); |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer37, 'uint32', 220, 185); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer23, 3_360, 515); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas0.getContext('webgpu'); |
| let buffer38 = device0.createBuffer({ |
| size: 7763, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let renderPassEncoder5 = commandEncoder42.beginRenderPass({colorAttachments: [{view: textureView28, depthSlice: 0, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup14, new Uint32Array(2824), 483, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 15, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(169).fill(122), /* required buffer size: 169 */ |
| {offset: 169, bytesPerRow: 222}, {width: 14, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| try { |
| adapter1.label = '\u52f9\u{1f906}\u{1fb7b}\uca2f\ub9a1\u0c98'; |
| } catch {} |
| let bindGroup21 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 176, resource: {buffer: buffer19, offset: 0, size: 208}}], |
| }); |
| let buffer39 = device0.createBuffer({ |
| size: 14319, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let textureView43 = texture20.createView({dimension: '2d', baseArrayLayer: 1}); |
| let computePassEncoder38 = commandEncoder43.beginComputePass({label: '27'}); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer18, 'uint16', 1_624, 187); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline3); |
| } catch {} |
| document.body.append(canvas1); |
| try { |
| adapter0.label = '\u35a8\u945a\u09a3\u2e17'; |
| } catch {} |
| let buffer40 = device0.createBuffer({ |
| label: '\u974a\ue86a\ubfd3\u001f\u{1f715}\u885e\uf00c\uef2f\udbb2\u{1fd15}', |
| size: 12262, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder18.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| device0.label = '\u0d13\u8b45\u8dc8\u055d\u0cfc\ube27\u9a99\ue741'; |
| } catch {} |
| try { |
| commandEncoder17.label = '\u{1fc24}\u{1fc9e}\u03c8\u31de\u{1f793}\u6049\u5b71\u7248\u9f21'; |
| } catch {} |
| let autogeneratedBindGroupLayout11 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder44 = device0.createCommandEncoder(); |
| let renderPassEncoder6 = commandEncoder44.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 167, |
| clearValue: { r: 230.0, g: -6.027, b: -39.97, a: 144.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 156239479, |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup9, new Uint32Array(198), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer31); |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpte170m', transfer: 'bt2020_10bit'} }); |
| let buffer41 = device0.createBuffer({size: 14304, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let computePassEncoder39 = commandEncoder45.beginComputePass({label: '28'}); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer2, 'uint32', 332, 3_187); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer3, 3_948, 9_340); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| var<private> vp3: vec4h = vec4h(28553.6, 2743.7, 3158.0, 7577.9); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(155) var<uniform> buffer44: array<array<array<mat4x4f, 17>, 1>, 1>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| @size(36) f0: array<atomic<i32>>, |
| } |
| |
| struct VertexOutput3 { |
| @builtin(position) f10: vec4f, |
| @location(12) f11: f32, |
| @location(6) f12: vec4i, |
| @location(14) f13: vec2i, |
| } |
| |
| struct VertexOutput4 { |
| @invariant @builtin(position) f14: vec4f, |
| } |
| |
| var<workgroup> vw14: array<atomic<i32>, 51>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw15: array<f16, 1>; |
| |
| var<private> vp4: VertexOutput4 = VertexOutput4(vec4f(0.1241, 0.1653, 0.05853, 0.3719)); |
| |
| var<workgroup> vw16: vec2<bool>; |
| |
| @group(0) @binding(78) var<storage, read_write> buffer42: array<atomic<u32>, 2>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(218) var st11: texture_storage_1d<r32float, write>; |
| |
| var<private> vp2: mat2x3f = mat2x3f(0.1719, 0.01088, 0.00765, 0.06545, 0.1017, 0.02412); |
| |
| var<workgroup> vw17: mat3x4f; |
| |
| @vertex @must_use |
| fn vertex3() -> VertexOutput3 { |
| var out: VertexOutput3; |
| vp4.f14 = vec4f(buffer44[0][0][u32(unconst_u32(182))][u32(unconst_u32(158))][u32(unconst_u32(188))]); |
| out.f11 = buffer44[0][u32(unconst_u32(98))][u32(unconst_u32(1))][u32(unconst_u32(37))][u32(unconst_u32(183))]; |
| let ptr15: ptr<uniform, mat4x4f> = &buffer44[u32(unconst_u32(12))][u32(unconst_u32(69))][u32(unconst_u32(256))]; |
| out.f11 = (*&buffer44)[u32(unconst_u32(7))][u32(unconst_u32(137))][u32(unconst_u32(713))][unconst_i32(2)].x; |
| return out; |
| _ = buffer44; |
| } |
| |
| @vertex |
| fn vertex4(@location(9) @interpolate(flat, center) a0: vec4u, @location(6) @interpolate(linear, center) a1: f32) -> VertexOutput4 { |
| var out: VertexOutput4; |
| let ptr16: ptr<uniform, array<mat4x4f, 17>> = &buffer44[0][u32(unconst_u32(64))]; |
| out.f14 -= vec4f(a1); |
| return out; |
| _ = buffer44; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute2() { |
| let ptr17: ptr<private, VertexOutput4> = &vp4; |
| atomicOr(&buffer42[u32(unconst_u32(21))], u32(unconst_u32(74))); |
| textureStore(st11, i32(unconst_i32(140)), vec4f(vec4f(f32(dot4I8Packed(atomicExchange(&(*&buffer42)[1], u32(unconst_u32(214))), u32(unconst_u32(71))))))); |
| vp4 = VertexOutput4(unpack4x8unorm(pack4x8unorm(buffer44[0][u32(unconst_u32(82))][u32(unconst_u32(390))][atomicLoad(&(*&buffer42)[1])]))); |
| _ = st11; |
| _ = buffer42; |
| _ = buffer44; |
| }`, |
| }); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let renderPassEncoder7 = commandEncoder46.beginRenderPass({ |
| colorAttachments: [{view: textureView43, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup18); |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer28, 'uint16', 5_628, 2_741); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 176, resource: {buffer: buffer32, offset: 5376, size: 936}}], |
| }); |
| let commandEncoder47 = device0.createCommandEncoder({}); |
| let texture41 = device0.createTexture({size: [8], dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let computePassEncoder40 = commandEncoder47.beginComputePass({label: '29'}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], stencilReadOnly: true}); |
| let sampler26 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 89.36, |
| }); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup11, new Uint32Array(4954), 506, 0); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 43, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(89).fill(89), /* required buffer size: 89 */ |
| {offset: 89, bytesPerRow: 493}, {width: 61, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let computePassEncoder41 = commandEncoder48.beginComputePass({label: '30'}); |
| let renderBundle1 = renderBundleEncoder1.finish({}); |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 49.80, |
| }); |
| try { |
| computePassEncoder37.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup15, new Uint32Array(891), 154, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 1732, new BigUint64Array(14588), 6399, 84); |
| } catch {} |
| let imageData8 = new ImageData(20, 96); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let texture42 = device0.createTexture({ |
| size: [216, 60, 2], |
| mipLevelCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder39.setBindGroup(2, bindGroup2, new Uint32Array(4038), 499, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder49.copyBufferToTexture({ |
| /* bytesInLastRow: 224 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 5232 */ |
| offset: 5232, |
| bytesPerRow: 7168, |
| buffer: buffer1, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 3, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 28, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder49.resolveQuerySet(querySet2, 58, 16, buffer36, 1792); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let pipeline4 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1}}); |
| try { |
| adapter1.label = '\u450c\u0ad5\ue180\u0792\u03fc\u96f4\uc954\u1eae\u4d16'; |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [{binding: 110, resource: {buffer: buffer34, offset: 256, size: 168}}], |
| }); |
| let renderPassEncoder8 = commandEncoder49.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 868.6, g: -822.5, b: 879.5, a: -879.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 180863908, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup21); |
| } catch {} |
| let buffer45 = device0.createBuffer({ |
| size: 23842, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder50 = device0.createCommandEncoder(); |
| let textureView44 = texture15.createView({dimension: '1d', aspect: 'all', format: 'r8sint'}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| commandEncoder50.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1392 */ |
| offset: 1392, |
| bytesPerRow: 46336, |
| buffer: buffer35, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder50.insertDebugMarker('\uc831'); |
| } catch {} |
| document.body.append(canvas1); |
| await gc(); |
| let autogeneratedBindGroupLayout12 = pipeline4.getBindGroupLayout(0); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 110, resource: {buffer: buffer2, offset: 1024}}], |
| }); |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| let textureView45 = texture34.createView({dimension: '2d', baseMipLevel: 0}); |
| let renderPassEncoder9 = commandEncoder51.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 6, |
| clearValue: { r: -919.2, g: -758.7, b: -26.81, a: -65.09, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 348052055, |
| }); |
| let sampler28 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.06, |
| compare: 'equal', |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup14, new Uint32Array(481), 226, 0); |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup10, []); |
| } catch {} |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'iec6196624'} }); |
| let buffer46 = device0.createBuffer({size: 38419, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let texture43 = device0.createTexture({ |
| size: [8, 8, 22], |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder34.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer31, 'uint16', 46, 141); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer34, 0, 676); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup25 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 176, resource: {buffer: buffer46, offset: 2304, size: 2844}}], |
| }); |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let computePassEncoder42 = commandEncoder50.beginComputePass({label: '31'}); |
| try { |
| computePassEncoder41.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer5, 'uint16', 248, 70); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer36, 180, 4_258); |
| } catch {} |
| try { |
| commandEncoder52.copyBufferToBuffer(buffer38, 448, buffer0, 1512, 2064); |
| } catch {} |
| try { |
| commandEncoder52.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 813 */ |
| offset: 813, |
| rowsPerImage: 67, |
| buffer: buffer6, |
| }, { |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout13 = pipeline2.getBindGroupLayout(0); |
| let buffer47 = device0.createBuffer({ |
| size: 24673, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder53 = device0.createCommandEncoder(); |
| let computePassEncoder43 = commandEncoder52.beginComputePass({label: '32'}); |
| let renderPassEncoder10 = commandEncoder53.beginRenderPass({ |
| label: '\u0316\u08ba\u1613\u029c\ubc9b\u6a33\u{1f936}\u7459\u9f2b\u5489', |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 18, |
| clearValue: { r: 366.1, g: -67.58, b: -367.9, a: 599.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 516220011, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup20, new Uint32Array(3509), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(42); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(4, buffer3, 0); |
| } catch {} |
| let imageData9 = new ImageData(68, 44); |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'linear'} }); |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 138, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 176, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 18, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 237, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| {binding: 473, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| ], |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup13, new Uint32Array(1778), 658, 0); |
| } catch {} |
| try { |
| computePassEncoder35.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer38, 0); |
| } catch {} |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let texture44 = device0.createTexture({ |
| size: [216, 60, 2], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder11 = commandEncoder54.beginRenderPass({ |
| colorAttachments: [{view: textureView28, depthSlice: 11, loadOp: 'load', storeOp: 'store'}], |
| maxDrawCount: 153760606, |
| }); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 64.53, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder32.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer14, 'uint16', 7_686, 1_757); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let textureView46 = texture3.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| computePassEncoder38.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup17); |
| } catch {} |
| let autogeneratedBindGroupLayout14 = pipeline3.getBindGroupLayout(1); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let texture45 = device0.createTexture({ |
| size: [216, 60, 2], |
| mipLevelCount: 2, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder12 = commandEncoder55.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 214, |
| clearValue: { r: -909.6, g: 250.2, b: -847.7, a: -618.2, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler30 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 98.47, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder42.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline3); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise5; |
| } catch {} |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let renderPassEncoder13 = commandEncoder56.beginRenderPass({ |
| colorAttachments: [{view: textureView28, depthSlice: 4, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(2, buffer47); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'hlg'} }); |
| let texture46 = device0.createTexture({ |
| size: [432, 120, 2], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup21, new Uint32Array(1739), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer39); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 428, new Float32Array(14606), 1472, 136); |
| } catch {} |
| document.body.append(img0); |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'bt709'} }); |
| let bindGroup26 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 138, resource: textureView43}, |
| {binding: 473, resource: sampler30}, |
| {binding: 30, resource: textureView9}, |
| {binding: 176, resource: {buffer: buffer10, offset: 0, size: 272}}, |
| {binding: 237, resource: textureView15}, |
| ], |
| }); |
| let texture47 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer40, 'uint32', 7_408, 468); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(6, buffer3); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| await gc(); |
| let bindGroup27 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 473, resource: sampler6}, |
| {binding: 176, resource: {buffer: buffer32, offset: 512, size: 660}}, |
| {binding: 237, resource: textureView8}, |
| {binding: 138, resource: textureView43}, |
| {binding: 30, resource: textureView9}, |
| ], |
| }); |
| let buffer48 = device0.createBuffer({ |
| size: 32615, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let sampler31 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMinClamp: 22.69, maxAnisotropy: 12}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder10.setScissorRect(52, 8, 105, 0); |
| } catch {} |
| let buffer49 = device0.createBuffer({size: 21758, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let textureView47 = texture13.createView({dimension: '2d'}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer5, 'uint32', 480, 13); |
| } catch {} |
| let bindGroup28 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 176, resource: {buffer: buffer8, offset: 3072, size: 1204}}], |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]}); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup23); |
| } catch {} |
| try { |
| computePassEncoder43.setBindGroup(1, bindGroup11, new Uint32Array(1321), 520, 0); |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer39, 'uint32', 4_080, 434); |
| } catch {} |
| let pipeline5 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, entryPoint: 'fragment0', constants: {1_579: 0}, targets: [{format: 'r8sint'}]}, |
| vertex: {module: shaderModule0, entryPoint: 'vertex0', constants: {override1: 0}, buffers: []}, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| document.body.append(canvas1); |
| let texture48 = device0.createTexture({ |
| size: [8, 8, 22], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView48 = texture34.createView({aspect: 'depth-only', arrayLayerCount: 1}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup11, new Uint32Array(1843), 641, 0); |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup26, new Uint32Array(798), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer39, 'uint32', 4_680, 4_241); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let img1 = await imageWithData(300, 47, '#10101010', '#20202020'); |
| let imageData10 = new ImageData(12, 64); |
| let buffer50 = device0.createBuffer({size: 18778, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| let computePassEncoder44 = commandEncoder57.beginComputePass({label: '33'}); |
| try { |
| computePassEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer40); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let textureView49 = texture8.createView({baseArrayLayer: 1, arrayLayerCount: 14}); |
| try { |
| computePassEncoder35.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 176, resource: {buffer: buffer34, offset: 1536, size: 268}}], |
| }); |
| let textureView50 = texture24.createView({aspect: 'depth-only', arrayLayerCount: 1}); |
| let sampler32 = device0.createSampler({addressModeV: 'clamp-to-edge', lodMinClamp: 88.09, lodMaxClamp: 97.30}); |
| try { |
| renderPassEncoder13.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer18); |
| } catch {} |
| let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let textureView51 = texture38.createView({}); |
| try { |
| renderPassEncoder9.beginOcclusionQuery(23); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setStencilReference(22); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer39, 'uint32', 400, 7_720); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer3, 332); |
| } catch {} |
| let pipeline6 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1'}}); |
| document.body.prepend(canvas1); |
| let bindGroup30 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 473, resource: sampler6}, |
| {binding: 176, resource: {buffer: buffer8, offset: 256, size: 10980}}, |
| {binding: 138, resource: textureView43}, |
| {binding: 237, resource: textureView15}, |
| {binding: 30, resource: textureView23}, |
| ], |
| }); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let computePassEncoder45 = commandEncoder58.beginComputePass({label: '34'}); |
| let sampler33 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 90.50}); |
| try { |
| computePassEncoder30.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup26, new Uint32Array(3068), 408, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer48, 3_384); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 2268, new Int16Array(18004), 8092, 80); |
| } catch {} |
| await gc(); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 562}); |
| let texture49 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 291}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView52 = texture32.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup30, new Uint32Array(184), 8, 0); |
| } catch {} |
| try { |
| adapter0.label = '\u3584\u8c2f\u{1f7a4}\u0d43\udaa6\u02ee\ubce1\u0871'; |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(88) var<storage, read> buffer52: array<array<array<array<f16, 1>, 8>, 15>>; |
| |
| fn fn0(a0: array<array<array<array<array<mat3x2f, 1>, 1>, 1>, 1>, 1>, a1: ptr<uniform, mat3x4h>) -> array<array<array<mat2x2h, 1>, 1>, 4> { |
| var out: array<array<array<mat2x2h, 1>, 1>, 4>; |
| out[bitcast<vec2u>(a0[0][0][0][0][0][unconst_i32(1)]).g][0][u32(unconst_u32(81))] += mat2x2h(vec2h(buffer53[1][33].br), vec2h(buffer53[1][33].ww)); |
| var vf51: vec2f = a0[u32(unconst_u32(922))][u32(unconst_u32(485))][u32(unconst_u32(45))][0][0][u32(unconst_u32(51))]; |
| vf51 *= vec2f(f32(buffer52[u32(unconst_u32(174))][u32(unconst_u32(668))][u32(unconst_u32(217))][0])); |
| let ptr18: ptr<storage, f16, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][u32(unconst_u32(12))][7][u32(unconst_u32(70))]; |
| let ptr19: ptr<storage, array<f16, 1>, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][14][7]; |
| out[u32(unconst_u32(467))][u32(unconst_u32(110))][u32(unconst_u32(240))] += mat2x2h((*a1)[u32(unconst_u32(49))][u32(unconst_u32(49))], (*a1)[u32(unconst_u32(49))][u32(unconst_u32(49))], (*a1)[u32(unconst_u32(49))][u32(unconst_u32(49))], (*a1)[u32(unconst_u32(49))][u32(unconst_u32(49))]); |
| out[3][u32(unconst_u32(98))][u32(unconst_u32(465))] = mat2x2h((*&buffer52)[u32(unconst_u32(137))][u32(unconst_u32(6))][7][0], (*&buffer52)[u32(unconst_u32(137))][u32(unconst_u32(6))][7][0], (*&buffer52)[u32(unconst_u32(137))][u32(unconst_u32(6))][7][0], (*&buffer52)[u32(unconst_u32(137))][u32(unconst_u32(6))][7][0]); |
| vf51 *= a0[0][0][u32(unconst_u32(459))][u32(unconst_u32(61))][0][unconst_i32(1)]; |
| let vf52: vec2f = a0[0][vec4u((*a1)[u32(unconst_u32(112))]).x][u32(unconst_u32(36))][u32(unconst_u32(29))][u32(unconst_u32(32))][u32(unconst_u32(293))]; |
| var vf53: f32 = a0[u32(unconst_u32(4))][u32(unconst_u32(159))][u32(unconst_u32(131))][u32(unconst_u32(254))][u32(unconst_u32(216))][u32(unconst_u32(129))][u32(unconst_u32(204))]; |
| let ptr20: ptr<storage, array<array<f16, 1>, 8>, read> = &buffer52[arrayLength(&buffer52)][u32(unconst_u32(536))]; |
| return out; |
| _ = buffer52; |
| _ = buffer53; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(218) var st12: texture_storage_1d<r32float, write>; |
| |
| @group(0) @binding(78) var<storage, read_write> buffer51: array<array<f16, 4>>; |
| |
| var<workgroup> vw19: array<FragmentOutput1, 1>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw21: atomic<i32>; |
| |
| struct T0 { |
| @align(16) @size(240) f0: array<i32>, |
| } |
| |
| struct FragmentOutput1 { |
| @location(3) @interpolate(linear, sample) f0: vec4f, |
| @location(2) @interpolate(flat) f1: vec4u, |
| @location(0) @interpolate(flat) f2: i32, |
| } |
| |
| var<workgroup> vw18: FragmentOutput1; |
| |
| fn fn1() -> vec4h { |
| var out: vec4h; |
| out *= vec4h(buffer53[u32(unconst_u32(367))][u32(unconst_u32(36))]); |
| out -= vec4h(buffer53[u32(unconst_u32(51))][33]); |
| out = vec4h(f16(atan(f32(unconst_f32(0.1049))))); |
| return out; |
| _ = buffer53; |
| } |
| |
| @group(0) @binding(155) var<uniform> buffer53: array<array<vec4f, 34>, 2>; |
| |
| var<workgroup> vw20: u32; |
| |
| @vertex |
| fn vertex5(@location(3) @interpolate(flat) a0: vec2u) -> @builtin(position) vec4f { |
| var out: vec4f; |
| let ptr21: ptr<uniform, array<vec4f, 34>> = &(*&buffer53)[u32(unconst_u32(64))]; |
| out = asin(vec4f(unconst_f32(0.08728), unconst_f32(0.03608), unconst_f32(0.08636), unconst_f32(0.1007))); |
| out = (*&buffer53)[u32(unconst_u32(98))][33]; |
| out = vec4f((*&buffer53)[1][u32(unconst_u32(74))][u32(unconst_u32(46))]); |
| var vf54 = fn1(); |
| out = degrees(vec2f(unconst_f32(-0.5924), unconst_f32(0.3208))).xxxx; |
| var vf55 = fn1(); |
| var vf56 = fn1(); |
| fn1(); |
| vf54 = vec4h((*ptr21)[33]); |
| let ptr22: ptr<uniform, array<vec4f, 34>> = &(*&buffer53)[1]; |
| vf55 *= vec4h(step(vec3f(unconst_f32(0.5977), unconst_f32(0.04327), unconst_f32(-0.03326)), vec3f(unconst_f32(0.04208), unconst_f32(0.2157), unconst_f32(0.02088))).grrb); |
| var vf57 = fn1(); |
| var vf58 = fn1(); |
| var vf59 = fn1(); |
| vf56 -= vec4h(f16((*ptr22)[pack4x8unorm(buffer53[pack4x8unorm((*ptr22)[33])][u32(unconst_u32(0))])][u32(unconst_u32(45))])); |
| var vf60 = fn1(); |
| let ptr23: ptr<uniform, vec4f> = &(*ptr22)[33]; |
| var vf61 = fn1(); |
| return out; |
| _ = buffer53; |
| } |
| |
| @fragment |
| fn fragment1(@location(6) @interpolate(flat) a0: vec4i) -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| out.f2 *= i32((*&buffer52)[arrayLength(&(*&buffer52))][14][u32(unconst_u32(2))][u32(unconst_u32(294))]); |
| let ptr24: ptr<storage, f16, read> = &buffer52[u32(unconst_u32(2))][14][7][u32(unconst_u32(211))]; |
| out.f2 ^= i32((*&buffer52)[arrayLength(&(*&buffer52))][14][u32(unconst_u32(3))][0]); |
| return out; |
| _ = buffer52; |
| } |
| |
| @compute @workgroup_size(4, 1, 1) |
| fn compute3() { |
| vw19[u32(unconst_u32(130))].f2 = bitcast<i32>(pack4xU8(vw18.f1)); |
| textureStore(st12, i32(unconst_i32(73)), vec4f(vec4f(unconst_f32(0.03561), unconst_f32(0.1989), unconst_f32(-0.02252), unconst_f32(0.1258)))); |
| var vf62 = fn1(); |
| var vf63 = fn1(); |
| let ptr25: ptr<storage, array<f16, 4>, read_write> = &buffer51[u32(unconst_u32(86))]; |
| let ptr26: ptr<storage, f16, read> = &buffer52[arrayLength(&buffer52)][u32(unconst_u32(620))][7][0]; |
| textureStore(st12, i32(unconst_i32(1)), vec4f(vec4f(unconst_f32(0.5581), unconst_f32(0.3503), unconst_f32(0.2403), unconst_f32(0.1688)))); |
| let ptr27: ptr<storage, f16, read_write> = &(*&buffer51)[u32(unconst_u32(113))][3]; |
| let ptr28: ptr<storage, array<array<f16, 1>, 8>, read> = &(*&buffer52)[arrayLength(&(*&buffer52))][14]; |
| vf63 = vec4h(buffer52[u32(unconst_u32(24))][14][7][0]); |
| let vf64: f32 = (*&vw19)[0].f0[u32(unconst_u32(24))]; |
| var vf65 = fn1(); |
| let ptr29: ptr<uniform, array<vec4f, 34>> = &buffer53[1]; |
| fn1(); |
| textureStore(st12, i32(unconst_i32(-88)), vec4f(vec4f(unconst_f32(0.05522), unconst_f32(-0.00955), unconst_f32(0.1845), unconst_f32(0.04235)))); |
| fn1(); |
| var vf66 = fn1(); |
| fn1(); |
| workgroupBarrier(); |
| var vf67 = fn1(); |
| _ = buffer53; |
| _ = st12; |
| _ = buffer51; |
| _ = buffer52; |
| }`, |
| }); |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 78, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 88, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 155, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 218, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let texture50 = device0.createTexture({ |
| size: [216, 60, 2], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture51 = device0.createTexture({ |
| size: [8, 8, 22], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder14 = commandEncoder59.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView52, |
| clearValue: { r: 846.2, g: 115.3, b: -140.2, a: -536.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 59.00, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup23, new Uint32Array(48), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder14.pushDebugGroup('\u0c79'); |
| } catch {} |
| let texture52 = device0.createTexture({ |
| size: [8], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler35 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 91.87, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await shaderModule2.getCompilationInfo(); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'film', transfer: 'smpteSt4281'} }); |
| let autogeneratedBindGroupLayout15 = pipeline1.getBindGroupLayout(1); |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let computePassEncoder46 = commandEncoder60.beginComputePass({label: '35'}); |
| let sampler36 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 47.55, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup18, new Uint32Array(585), 379, 0); |
| } catch {} |
| try { |
| computePassEncoder43.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer20, 52, 116); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let textureView53 = texture20.createView({dimension: 'cube-array', baseArrayLayer: 6, arrayLayerCount: 6}); |
| let texture53 = device0.createTexture({ |
| label: '\u0b3d\u08be\u299b\u0a01\u295d\u0e78', |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView54 = texture25.createView({arrayLayerCount: 1}); |
| let renderPassEncoder15 = commandEncoder61.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 38, |
| clearValue: { r: 319.5, g: 73.75, b: -233.5, a: -465.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder29.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup18); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let imageData11 = new ImageData(52, 28); |
| let autogeneratedBindGroupLayout16 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let renderPassEncoder16 = commandEncoder62.beginRenderPass({colorAttachments: [{view: textureView28, depthSlice: 4, loadOp: 'load', storeOp: 'discard'}]}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout17 = pipeline5.getBindGroupLayout(1); |
| try { |
| computePassEncoder41.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder46.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.beginOcclusionQuery(202); |
| } catch {} |
| try { |
| renderPassEncoder9.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder11.setScissorRect(39, 15, 3, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer37, 'uint32', 80, 42); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup22, []); |
| } catch {} |
| document.body.append(img1); |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder47 = commandEncoder63.beginComputePass({label: '36'}); |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup10, new Uint32Array(157), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer20, 'uint32', 932, 2_584); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(4, buffer40, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer54 = device0.createBuffer({ |
| size: 24508, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let texture55 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView55 = texture37.createView({}); |
| let computePassEncoder48 = commandEncoder64.beginComputePass({label: '37'}); |
| try { |
| computePassEncoder36.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup21, new Uint32Array(515), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer39, 'uint32', 2_908, 406); |
| } catch {} |
| try { |
| renderPassEncoder14.popDebugGroup(); |
| } catch {} |
| let autogeneratedBindGroupLayout18 = pipeline5.getBindGroupLayout(1); |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder48.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup8, new Uint32Array(1246), 360, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer39, 'uint32', 392, 22); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 364 widthInBlocks: 91 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1848 */ |
| offset: 1848, |
| bytesPerRow: 12288, |
| buffer: buffer3, |
| }, { |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 27, y: 24, z: 0}, |
| aspect: 'all', |
| }, {width: 91, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder3.insertDebugMarker('\u0473'); |
| } catch {} |
| let promise6 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4}}); |
| await gc(); |
| let imageBitmap2 = await createImageBitmap(videoFrame5); |
| let buffer55 = device0.createBuffer({size: 8345, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let textureView56 = texture4.createView({arrayLayerCount: 1}); |
| let computePassEncoder49 = commandEncoder66.beginComputePass({label: '38'}); |
| let sampler37 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 90.23, |
| compare: 'always', |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup10, new Uint32Array(606), 128, 0); |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer46, 12_936, 461); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer4, 2_040, 89); |
| } catch {} |
| try { |
| buffer30.unmap(); |
| } catch {} |
| let bindGroup31 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 218, resource: textureView15}, |
| {binding: 155, resource: {buffer: buffer20, offset: 0, size: 1763}}, |
| {binding: 78, resource: {buffer: buffer39, offset: 2304, size: 1404}}, |
| {binding: 88, resource: {buffer: buffer20, offset: 1024, size: 804}}, |
| ], |
| }); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle2 = renderBundleEncoder4.finish(); |
| let sampler38 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 88.66, |
| }); |
| try { |
| computePassEncoder21.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer32, 'uint32', 1_960, 268); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer32); |
| } catch {} |
| try { |
| buffer27.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer48, 412, new Int16Array(5084), 183, 232); |
| } catch {} |
| document.body.append(img1); |
| let computePassEncoder50 = commandEncoder67.beginComputePass({label: '39'}); |
| let renderBundle3 = renderBundleEncoder3.finish({}); |
| let sampler39 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 85.88}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup26, new Uint32Array(469), 117, 0); |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer31, 160, 202); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup17, new Uint32Array(2099), 89, 0); |
| } catch {} |
| try { |
| commandEncoder65.resolveQuerySet(querySet0, 52, 102, buffer32, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.insertDebugMarker('\uf9ed'); |
| } catch {} |
| document.body.prepend(img1); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let computePassEncoder51 = commandEncoder65.beginComputePass({label: '40'}); |
| let renderPassEncoder17 = commandEncoder68.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView43, |
| clearValue: { r: -120.3, g: 541.9, b: 175.6, a: -97.78, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder44.setBindGroup(2, bindGroup20, new Uint32Array(661), 25, 0); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle2, renderBundle3, renderBundle0, renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer5, 'uint16', 96, 120); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 724, new BigUint64Array(19923), 1585, 4); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 176, resource: {buffer: buffer8, offset: 10240, size: 836}}], |
| }); |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let computePassEncoder52 = commandEncoder69.beginComputePass({label: '41'}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup20, new Uint32Array(382), 60, 0); |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline4); |
| } catch {} |
| let autogeneratedBindGroupLayout19 = pipeline1.getBindGroupLayout(1); |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let textureView57 = texture33.createView({}); |
| let computePassEncoder53 = commandEncoder70.beginComputePass({label: '42'}); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup15, new Uint32Array(253), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer3, 'uint16', 6_008, 6_089); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 32, new BigUint64Array(584)); |
| } catch {} |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'film', transfer: 'gamma28curve'} }); |
| try { |
| computePassEncoder45.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup11, new Uint32Array(4503), 884, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline5); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| document.body.append(canvas1); |
| try { |
| globalThis.someLabel = buffer19.label; |
| } catch {} |
| let commandEncoder71 = device0.createCommandEncoder(); |
| let textureView58 = texture3.createView({arrayLayerCount: 1}); |
| let computePassEncoder54 = commandEncoder71.beginComputePass({label: '43'}); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer40, 'uint16', 1_248, 8_583); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt470m', transfer: 'gamma28curve'} }); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 374}); |
| let texture56 = device0.createTexture({size: [8, 8, 151], dimension: '3d', format: 'r8sint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder55 = commandEncoder72.beginComputePass({label: '44'}); |
| try { |
| computePassEncoder45.setBindGroup(1, bindGroup29, new Uint32Array(820), 391, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup32, new Uint32Array(26), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer39, 1_620, 4_884); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(2, bindGroup19, new Uint32Array(972), 24, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 1, |
| origin: {x: 12, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(13).fill(52), /* required buffer size: 13 */ |
| {offset: 13, bytesPerRow: 78}, {width: 8, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData12 = new ImageData(12, 60); |
| let autogeneratedBindGroupLayout20 = pipeline5.getBindGroupLayout(1); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout8, |
| entries: [{binding: 176, resource: {buffer: buffer45, offset: 5632, size: 2488}}], |
| }); |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let computePassEncoder56 = commandEncoder73.beginComputePass({label: '45'}); |
| try { |
| renderPassEncoder4.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline5); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup34 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 176, resource: {buffer: buffer48, offset: 3072, size: 3296}}], |
| }); |
| let buffer56 = device0.createBuffer({size: 6908, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView59 = texture39.createView({dimension: '2d'}); |
| try { |
| renderPassEncoder0.setViewport(1.8364186362947357, 13.775122652543008, 85.73120756660893, 10.89197759727269, 0.9512455715763238, 0.9837505436118698); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(2, buffer20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup32); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline3); |
| } catch {} |
| let imageData13 = new ImageData(8, 12); |
| try { |
| renderPassEncoder13.executeBundles([renderBundle2, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer55, 'uint16', 1_200, 245); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer47, 0, 4_797); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer55, 'uint16', 844, 993); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let buffer57 = device0.createBuffer({size: 5783, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let texture57 = device0.createTexture({ |
| size: {width: 108}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder57 = commandEncoder74.beginComputePass({label: '46'}); |
| try { |
| renderBundleEncoder2.setVertexBuffer(2, buffer37, 0, 23); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let textureView60 = texture56.createView({}); |
| let renderBundle4 = renderBundleEncoder2.finish({}); |
| try { |
| computePassEncoder15.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle1, renderBundle3, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let buffer58 = device0.createBuffer({ |
| size: 1475, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let texture58 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 151}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture59 = gpuCanvasContext0.getCurrentTexture(); |
| let renderPassEncoder18 = commandEncoder75.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: -421.6, g: -598.4, b: 986.7, a: -469.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet5, |
| maxDrawCount: 367324139, |
| }); |
| let sampler40 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 88.20}); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 83, y: 35, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup35 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 176, resource: {buffer: buffer2, offset: 3072}}], |
| }); |
| let buffer59 = device0.createBuffer({size: 9766, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let textureView61 = texture27.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder16.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(7, buffer40, 1_016, 3_737); |
| } catch {} |
| try { |
| commandEncoder76.copyBufferToBuffer(buffer37, 72, buffer11, 2092, 412); |
| } catch {} |
| try { |
| commandEncoder76.resolveQuerySet(querySet3, 321, 35, buffer9, 512); |
| } catch {} |
| await gc(); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame4}); |
| document.body.prepend(img0); |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let textureView62 = texture8.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6}); |
| let computePassEncoder58 = commandEncoder76.beginComputePass({label: '47'}); |
| let renderPassEncoder19 = commandEncoder77.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 432.6, g: -438.0, b: -492.7, a: 468.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet5, |
| }); |
| let sampler41 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.56, |
| compare: 'greater-equal', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder55.setPipeline(pipeline7); |
| } catch {} |
| let querySet6 = device0.createQuerySet({type: 'occlusion', count: 360}); |
| let textureView63 = texture54.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder47.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer45); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'smpte240m'} }); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 176, resource: {buffer: buffer20, offset: 2304, size: 2868}}], |
| }); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let texture60 = device0.createTexture({size: [108, 30, 2], format: 'r8sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder59 = commandEncoder78.beginComputePass({label: '48'}); |
| try { |
| computePassEncoder49.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 8320, new Int16Array(2940), 969, 988); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(2).fill(173), /* required buffer size: 2 */ |
| {offset: 2, rowsPerImage: 9}, {width: 3, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule4}}); |
| await gc(); |
| try { |
| adapter1.label = '\u029c\ub9df\u76fc'; |
| } catch {} |
| let querySet7 = device0.createQuerySet({type: 'occlusion', count: 611}); |
| let texture61 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup16, new Uint32Array(2263), 148, 0); |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer17.unmap(); |
| } catch {} |
| try { |
| computePassEncoder58.pushDebugGroup('\ucf33'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| let textureView64 = texture32.createView({format: 'r8sint', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderPassEncoder20 = commandEncoder79.beginRenderPass({ |
| colorAttachments: [{view: textureView31, loadOp: 'load', storeOp: 'discard'}], |
| occlusionQuerySet: querySet6, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup33); |
| } catch {} |
| try { |
| renderPassEncoder20.setBlendConstant({ r: -294.2, g: 796.8, b: -577.6, a: -17.20, }); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer32, 'uint32', 1_424, 1_700); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer47, 64, 8_170); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 18, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 8, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 156, height: 115, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 23, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout21 = pipeline6.getBindGroupLayout(0); |
| let texture62 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r8sint'], |
| }); |
| try { |
| computePassEncoder50.setBindGroup(2, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer2, 'uint32', 1_932, 948); |
| } catch {} |
| try { |
| adapter0.label = '\u0358\u{1f7a4}\u{1fb58}\u0295'; |
| } catch {} |
| let autogeneratedBindGroupLayout22 = pipeline7.getBindGroupLayout(0); |
| let buffer60 = device0.createBuffer({ |
| size: 6476, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView65 = texture20.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 12}); |
| try { |
| computePassEncoder57.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup10, new Uint32Array(349), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline5); |
| } catch {} |
| let autogeneratedBindGroupLayout23 = pipeline7.getBindGroupLayout(0); |
| let commandEncoder80 = device0.createCommandEncoder(); |
| let texture63 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let renderPassEncoder21 = commandEncoder80.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 19, |
| clearValue: { r: -804.3, g: -864.6, b: -440.0, a: 279.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| let sampler42 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup32, new Uint32Array(197), 22, 0); |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame14, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 126, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout24 = pipeline7.getBindGroupLayout(0); |
| let textureView66 = texture33.createView({dimension: '2d', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder56.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup22, new Uint32Array(4654), 3_095, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBlendConstant({ r: -783.6, g: 2.115, b: 912.5, a: 767.2, }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 1000, new Float32Array(2172), 60, 148); |
| } catch {} |
| let autogeneratedBindGroupLayout25 = pipeline6.getBindGroupLayout(1); |
| let texture64 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView67 = texture30.createView({}); |
| try { |
| computePassEncoder49.setBindGroup(3, bindGroup18, new Uint32Array(383), 232, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline3); |
| } catch {} |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture65 = device0.createTexture({size: [216], dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.COPY_SRC}); |
| let renderPassEncoder22 = commandEncoder81.beginRenderPass({colorAttachments: [{view: textureView64, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder52.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer40, 'uint16', 1_118, 791); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let computePassEncoder60 = commandEncoder82.beginComputePass({label: '49'}); |
| try { |
| computePassEncoder41.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer38, 'uint32', 2_036, 74); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| await gc(); |
| let commandEncoder83 = device0.createCommandEncoder({label: '\u3f40\u0b98\u0477\u0037'}); |
| let computePassEncoder61 = commandEncoder83.beginComputePass({label: '50'}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(1_134).fill(110), /* required buffer size: 1_134 */ |
| {offset: 648, bytesPerRow: 54, rowsPerImage: 9}, {width: 0, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 0, y: 10 }, |
| flipY: false, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 47, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture66 = device0.createTexture({size: [108, 30, 2], format: 'r8sint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView68 = texture5.createView({}); |
| try { |
| computePassEncoder31.setBindGroup(3, bindGroup28); |
| } catch {} |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup3, new Uint32Array(885), 157, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 18, y: 23, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(55).fill(201), /* required buffer size: 55 */ |
| {offset: 55, bytesPerRow: 712, rowsPerImage: 120}, {width: 82, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = commandEncoder15.label; |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder(); |
| let texture67 = device0.createTexture({size: [8, 8, 324], dimension: '3d', format: 'r8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let computePassEncoder62 = commandEncoder84.beginComputePass({label: '51'}); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r8sint']}); |
| let renderBundle5 = renderBundleEncoder5.finish({}); |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup20, new Uint32Array(570), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle5, renderBundle0, renderBundle1, renderBundle2]); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let texture68 = gpuCanvasContext2.getCurrentTexture(); |
| let renderPassEncoder23 = commandEncoder85.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView64, |
| clearValue: { r: 328.2, g: -594.1, b: 242.1, a: -196.2, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer58, 'uint32', 8, 5); |
| } catch {} |
| let textureView69 = texture35.createView({}); |
| try { |
| computePassEncoder62.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer45, 2_760, 5_488); |
| } catch {} |
| let sampler43 = device0.createSampler({ |
| addressModeV: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 70.06, |
| lodMaxClamp: 92.84, |
| compare: 'greater-equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| computePassEncoder50.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(135, 11, 7, 34); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline5); |
| } catch {} |
| let promise7 = shaderModule1.getCompilationInfo(); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(619).fill(130), /* required buffer size: 619 */ |
| {offset: 59, bytesPerRow: 56}, {width: 7, height: 10, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| document.body.prepend(canvas2); |
| let autogeneratedBindGroupLayout26 = pipeline2.getBindGroupLayout(0); |
| let buffer61 = device0.createBuffer({ |
| size: 5078, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView70 = texture0.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler44 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 98.53, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| computePassEncoder60.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder10.setBlendConstant({ r: -507.1, g: -217.5, b: -601.2, a: -700.9, }); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext3 = canvas2.getContext('webgpu'); |
| try { |
| await promise8; |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(196, 540); |
| let texture69 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| dimension: '2d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView71 = texture1.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline5); |
| } catch {} |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'gamma22curve'} }); |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T0 { |
| @align(16) @size(240) f0: array<atomic<u32>>, |
| } |
| |
| @group(0) @binding(88) var<storage, read> buffer63: array<array<array<f16, 5>, 4>, 6>; |
| |
| var<workgroup> vw23: f32; |
| |
| @group(0) @binding(155) var<uniform> buffer64: array<array<mat2x2f, 34>, 2>; |
| |
| var<workgroup> vw22: array<atomic<u32>, 1>; |
| |
| fn fn0(a0: ptr<storage, array<u32>, read_write>) -> array<array<FragmentOutput2, 1>, 1> { |
| var out: array<array<FragmentOutput2, 1>, 1>; |
| var vf68: vec4f = unpack4x8snorm(u32(unconst_u32(37))); |
| (*a0)[u32(unconst_u32(104))] <<= pack4xU8Clamp(unpack4xU8(u32((*&buffer64)[u32(unconst_u32(157))][u32(unconst_u32(802))][u32(unconst_u32(304))][u32(unconst_u32(96))]))); |
| vf68 = (*&buffer64)[1][33][u32(unconst_u32(141))].yxyx; |
| var vf69: vec4h = clamp(vec4h(unconst_f16(890.8), unconst_f16(16468.2), unconst_f16(-46138.3), unconst_f16(-4785.8)), vec4h(unconst_f16(-931.1), unconst_f16(-20409.7), unconst_f16(11490.4), unconst_f16(23781.6)), vec4h(unconst_f16(839.9), unconst_f16(2821.5), unconst_f16(13659.2), unconst_f16(18424.8))); |
| return out; |
| _ = buffer64; |
| } |
| |
| fn fn1() -> vec4f { |
| var out: vec4f; |
| out = vec4f((*&buffer64)[u32(unconst_u32(157))][33][u32(unconst_u32(311))][u32(unconst_u32(423))]); |
| var vf70: vec2f = buffer64[1][u32(unconst_u32(445))][u32(unconst_u32(75))]; |
| let ptr30: ptr<storage, array<array<f16, 5>, 4>, read> = &(*&buffer63)[u32(unconst_u32(673))]; |
| let ptr31: ptr<storage, f16, read> = &(*ptr30)[u32(unconst_u32(10))][u32(unconst_u32(282))]; |
| return out; |
| _ = buffer64; |
| _ = buffer63; |
| } |
| |
| struct FragmentOutput2 { |
| @location(2) f0: u32, |
| @location(0) @interpolate(flat) f1: i32, |
| @location(5) f2: vec2f, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @vertex |
| fn vertex6(@location(6) a0: vec2u, @location(11) @interpolate(flat) a1: vec2i, @location(2) a2: f32, @location(14) @interpolate(flat) a3: vec2i) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = (*&buffer64)[u32(unconst_u32(60))][33][unconst_i32(1)].yyxx; |
| var vf71: f16 = trunc(f16(unconst_f16(7495.7))); |
| vf71 = f16((*&buffer64)[1][33][u32(unconst_u32(77))][pack2x16float(buffer64[u32(unconst_u32(219))][33][u32(unconst_u32(53))])]); |
| out = buffer64[u32(unconst_u32(69))][u32(unconst_u32(116))][unconst_i32(1)].rgrr; |
| let ptr32: ptr<uniform, array<mat2x2f, 34>> = &(*&buffer64)[1]; |
| var vf72: f32 = (*ptr32)[u32(unconst_u32(65))][u32(unconst_u32(0))][u32(unconst_u32(147))]; |
| vf71 = log(vec4h(unconst_f16(35360.3), unconst_f16(923.1), unconst_f16(2523.7), unconst_f16(-2338.7)))[3]; |
| out = vec4f(atan(vec2h(unconst_f16(1444.2), unconst_f16(21629.9))).yyyy); |
| vf72 += (*ptr32)[33][unconst_i32(0)][1]; |
| var vf73: f32 = length(f32(unconst_f32(0.07762))); |
| vf72 *= bitcast<f32>(a1[u32(unconst_u32(272))]); |
| vf71 += f16(vf72); |
| vf72 += buffer64[1][33][unconst_i32(1)][1]; |
| var vf74: vec2i = a1; |
| let ptr33: ptr<uniform, array<mat2x2f, 34>> = &buffer64[1]; |
| vf71 = f16((*ptr32)[u32(unconst_u32(160))][a0.y][u32(unconst_u32(202))]); |
| let ptr34: ptr<uniform, mat2x2f> = &buffer64[1][u32(unconst_u32(146))]; |
| vf72 = buffer64[1][33][u32(unconst_u32(172))][0]; |
| vf74 = bitcast<vec2i>((*ptr32)[33][unconst_i32(0)]); |
| return out; |
| _ = buffer64; |
| } |
| |
| @fragment |
| fn fragment2() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| var vf75 = fn1(); |
| fn1(); |
| fn1(); |
| out = FragmentOutput2(u32((*&buffer63)[5][3][4]), i32((*&buffer63)[5][3][4]), vec2f(f32((*&buffer63)[5][3][4]))); |
| fn1(); |
| out.f0 >>= u32((*&buffer63)[u32(round(vec4f(unconst_f32(0.02035), unconst_f32(0.03955), unconst_f32(0.2596), unconst_f32(0.1591))).z)][u32(unconst_u32(13))][4]); |
| out.f2 *= vec2f(f32((*&buffer63)[5][3][u32(unconst_u32(79))])); |
| let ptr35: ptr<storage, array<array<f16, 5>, 4>, read> = &buffer63[u32(unconst_u32(145))]; |
| out.f1 |= i32((*&buffer63)[5][3][4]); |
| discard; |
| out.f1 = i32((*&buffer63)[u32(unconst_u32(178))][3][4]); |
| out = FragmentOutput2(u32((*&buffer63)[5][3][4]), i32((*&buffer63)[5][3][4]), vec2f(f32((*&buffer63)[5][3][4]))); |
| var vf76: vec4f = round(vec4f(unconst_f32(0.1407), unconst_f32(0.03809), unconst_f32(0.3144), unconst_f32(0.3352))); |
| fn1(); |
| out.f1 = bitcast<i32>(mix(vec3f(unconst_f32(0.05456), unconst_f32(0.3907), unconst_f32(0.3323)), vec3f(unconst_f32(0.02008), unconst_f32(0.3919), unconst_f32(-0.5181)), f32(unconst_f32(0.3941))).r); |
| out.f0 = bitcast<vec2u>(buffer64[1][u32(unconst_u32(315))][u32(unconst_u32(46))])[0]; |
| return out; |
| _ = buffer64; |
| _ = buffer63; |
| } |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute4(@builtin(local_invocation_id) a0: vec3u) { |
| }`, |
| }); |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let buffer65 = device0.createBuffer({size: 2652, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder53.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup26, new Uint32Array(1338), 417, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| let autogeneratedBindGroupLayout27 = pipeline7.getBindGroupLayout(0); |
| let bindGroup37 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout19, |
| entries: [{binding: 176, resource: {buffer: buffer32, offset: 512, size: 700}}], |
| }); |
| let textureView72 = texture62.createView({baseArrayLayer: 4, arrayLayerCount: 2}); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer14, 'uint32', 2_340, 2_058); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(3, buffer1, 0); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder58.setBindGroup(1, bindGroup17, new Uint32Array(6024), 936, 0); |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup14, new Uint32Array(8098), 150, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setScissorRect(4, 0, 55, 4); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(6, buffer36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup19, new Uint32Array(556), 7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(3, buffer39, 1_052, 29); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 24, new BigUint64Array(2767), 115, 24); |
| } catch {} |
| let textureView73 = texture46.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| computePassEncoder40.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup32, new Uint32Array(1675), 157, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer49, 1940, new Int16Array(23729), 2576, 4744); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(4_876).fill(111), /* required buffer size: 4_876 */ |
| {offset: 164, bytesPerRow: 38, rowsPerImage: 31}, {width: 0, height: 0, depthOrArrayLayers: 5}); |
| } catch {} |
| let img2 = await imageWithData(1, 131, '#10101010', '#20202020'); |
| let autogeneratedBindGroupLayout28 = pipeline3.getBindGroupLayout(0); |
| let bindGroup38 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 23, resource: textureView7}]}); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup28, new Uint32Array(220), 34, 0); |
| } catch {} |
| try { |
| computePassEncoder61.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 19, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext4 = offscreenCanvas1.getContext('webgpu'); |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 304, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder54.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer5, 'uint16', 198, 87); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer37, 296); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup28, new Uint32Array(5875), 210, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout29 = pipeline1.getBindGroupLayout(0); |
| let bindGroup39 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout27, |
| entries: [ |
| {binding: 155, resource: {buffer: buffer33, offset: 2560, size: 7039}}, |
| {binding: 218, resource: textureView15}, |
| {binding: 78, resource: {buffer: buffer60, offset: 0, size: 464}}, |
| ], |
| }); |
| try { |
| computePassEncoder46.setBindGroup(3, bindGroup38, new Uint32Array(1063), 497, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle2, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer32, 'uint16', 34, 379); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(5, buffer1, 588, 683); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer66 = device0.createBuffer({ |
| size: 3015, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup17, []); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer40, 6_708); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer61); |
| } catch {} |
| try { |
| computePassEncoder58.popDebugGroup(); |
| } catch {} |
| let autogeneratedBindGroupLayout30 = pipeline0.getBindGroupLayout(0); |
| let buffer67 = device0.createBuffer({ |
| size: 1469, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let sampler45 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 86.16, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup16, new Uint32Array(1856), 391, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup29, new Uint32Array(390), 127, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer5, 'uint16', 1_360, 9); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup19, new Uint32Array(8), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer19, 'uint32', 672, 133); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let autogeneratedBindGroupLayout31 = pipeline6.getBindGroupLayout(1); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup22, new Uint32Array(1274), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup29, new Uint32Array(1579), 197, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle4, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer3, 'uint16', 270, 285); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer66, 0, 284); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup20, new Uint32Array(1823), 286, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(2, buffer20); |
| } catch {} |
| try { |
| querySet4.destroy(); |
| } catch {} |
| try { |
| renderPassEncoder12.pushDebugGroup('\u{1ff3a}'); |
| } catch {} |
| try { |
| renderPassEncoder12.popDebugGroup(); |
| } catch {} |
| let pipeline9 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}}); |
| let imageBitmap3 = await createImageBitmap(videoFrame10); |
| let imageData14 = new ImageData(40, 12); |
| let textureView74 = texture42.createView({arrayLayerCount: 1}); |
| let renderBundle6 = renderBundleEncoder6.finish({}); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup22, new Uint32Array(1893), 110, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setScissorRect(10, 4, 4, 6); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(41.17133278483209, 13.01258588797682, 7.696683188454034, 0.7017917399289394, 0.6716065789241313, 0.7989130962737142); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer66, 'uint32', 3_012, 1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(5, buffer3, 14_776, 714); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(11640) override override13: u32; |
| |
| @group(0) @binding(155) var<uniform> buffer70: array<array<mat2x3f, 2>, 17>; |
| |
| @id(25386) override override14: bool; |
| |
| var<private> vp5: vec4h = vec4h(7700.9, 34450.8, 5527.8, 3586.5); |
| |
| @id(60291) override override10: f16; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| override override12: u32; |
| |
| @id(13019) override override11: f16 = 16405.7; |
| |
| struct FragmentOutput3 { |
| @location(0) f0: vec4i, |
| } |
| |
| @id(43836) override override15: f16; |
| |
| @group(0) @binding(78) var<storage, read_write> buffer68: T0; |
| |
| @group(0) @binding(218) var st14: texture_storage_1d<r32float, write>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp6 = array(modf(f16(-20004.2))); |
| |
| struct T0 { |
| @align(8) @size(8) f0: atomic<u32>, |
| } |
| |
| @vertex |
| fn vertex7(@location(6) @interpolate(linear) a0: f32, @location(1) @interpolate(linear, center) a1: f32, @location(14) @interpolate(flat, center) a2: vec2i) -> @builtin(position) vec4f { |
| var out: vec4f; |
| vp5 = vec4h(buffer70[u32(unconst_u32(56))][1][unconst_i32(1)].rrgg); |
| let vf77: f32 = buffer70[u32(unconst_u32(246))][1][u32(unconst_u32(53))][u32(vp6[0].whole)]; |
| let vf78: f32 = (*&buffer70)[u32(unconst_u32(175))][u32(unconst_u32(102))][u32(unconst_u32(27))][u32(unconst_u32(38))]; |
| let ptr36 = &vp6[0]; |
| vp5 = vec4h((*&buffer70)[u32(unconst_u32(84))][1][unconst_i32(1)].xyxy); |
| vp6[u32(unconst_u32(10))] = modf(f16((*&buffer70)[u32(unconst_u32(200))][1][unconst_i32(0)].x)); |
| let ptr37: ptr<uniform, mat2x3f> = &(*&buffer70)[16][u32(unconst_u32(70))]; |
| vp6[u32(unconst_u32(44))] = modf(f16(buffer70[16][1][u32(unconst_u32(26))][2])); |
| let ptr38: ptr<uniform, array<mat2x3f, 2>> = &(*&buffer70)[u32(unconst_u32(111))]; |
| vp6[u32(unconst_u32(33))].fract -= vp6[0].whole; |
| let vf79: f32 = vf77; |
| vp6[u32(unconst_u32(61))].whole = vec3h((*&buffer70)[bitcast<u32>((*ptr38)[1][unconst_i32(1)].z)][u32(unconst_u32(326))][unconst_i32(0)]).z; |
| let ptr39: ptr<private, f16> = &(*ptr36).whole; |
| vp5 = vec4h((*&buffer70)[16][1][unconst_i32(0)].xxzx); |
| let ptr40: ptr<uniform, array<array<mat2x3f, 2>, 17>> = &buffer70; |
| let vf80: f32 = (*ptr40)[16][1][u32(unconst_u32(376))][u32(unconst_u32(245))]; |
| var vf81: vec3f = buffer70[16][u32(unconst_u32(154))][u32(unconst_u32(255))]; |
| vf81 = unpack4x8unorm(u32(unconst_u32(109))).aab; |
| var vf82: f32 = vf79; |
| let vf83: f32 = a1; |
| let vf84: vec3f = (*&buffer70)[u32(unconst_u32(112))][1][u32(unconst_u32(912))]; |
| let ptr41: ptr<uniform, mat2x3f> = &(*&buffer70)[u32(unconst_u32(20))][u32(unconst_u32(99))]; |
| return out; |
| _ = buffer70; |
| } |
| |
| @fragment |
| fn fragment3() -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| var vf85: f32 = (*&buffer70)[16][1][u32(unconst_u32(36))][u32(unconst_u32(24))]; |
| let ptr42: ptr<uniform, mat2x3f> = &(*&buffer70)[16][u32(unconst_u32(90))]; |
| let vf86: u32 = override13; |
| return out; |
| _ = override13; |
| _ = buffer70; |
| } |
| |
| @compute @workgroup_size(1, 1, 2) |
| fn compute5() { |
| let ptr43: ptr<uniform, mat2x3f> = &buffer70[16][u32(unconst_u32(51))]; |
| vp6[0] = modf(f16((*&buffer70)[16][1][unconst_i32(1)].y)); |
| let ptr44: ptr<uniform, mat2x3f> = &buffer70[u32(unconst_u32(74))][u32(unconst_u32(262))]; |
| let vf87: u32 = pack4x8unorm(vec4f(unconst_f32(0.2294), unconst_f32(0.07094), unconst_f32(0.00522), unconst_f32(0.3442))); |
| var vf88: vec3f = buffer70[u32(unconst_u32(43))][u32(unconst_u32(186))][u32(unconst_u32(93))]; |
| atomicExchange(&buffer68.f0, bitcast<u32>(step(f32(unconst_f32(0.1465)), f32(unconst_f32(0.05555))))); |
| textureStore(st14, i32(unconst_i32(31)), vec4f(vec4f(unconst_f32(0.2449), unconst_f32(0.1254), unconst_f32(-0.2737), unconst_f32(-0.07110)))); |
| textureStore(st14, i32(unconst_i32(113)), vec4f(vec4f(unconst_f32(-0.01515), unconst_f32(0.00036), unconst_f32(0.02583), unconst_f32(0.4434)))); |
| var vf89: u32 = override13; |
| _ = override13; |
| _ = st14; |
| _ = buffer68; |
| _ = buffer70; |
| }`, |
| }); |
| let buffer71 = device0.createBuffer({size: 650, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r8sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup19, []); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer14, 'uint16', 1_230, 1_053); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 39, y: 50, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| document.body.prepend(img2); |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'smpte170m'} }); |
| let texture70 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle7 = renderBundleEncoder9.finish({}); |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup18, new Uint32Array(652), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup17, new Uint32Array(14), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer57, 'uint32', 1_368, 628); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(4, undefined, 0, 277_927_175); |
| } catch {} |
| let sampler46 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'linear', compare: 'equal'}); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer61.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, viewFormats: []}); |
| } catch {} |
| let texture71 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle8 = renderBundleEncoder8.finish({}); |
| let sampler47 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 77.96, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup2, new Uint32Array(301), 44, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer19, 'uint16', 276, 116); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer36); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup23); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup8, new Uint32Array(345), 62, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer58, 'uint16', 34, 160); |
| } catch {} |
| try { |
| buffer47.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 97, y: 60, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer72 = device0.createBuffer({ |
| size: 20000, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture72 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| mipLevelCount: 3, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView75 = texture19.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder3.setScissorRect(10, 5, 16, 5); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer32, 'uint32', 424, 1_267); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer48, 0, 18_203); |
| } catch {} |
| let pipeline10 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute2'}}); |
| let buffer73 = device0.createBuffer({ |
| size: 1115, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder86 = device0.createCommandEncoder(); |
| let textureView76 = texture33.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let textureView77 = texture35.createView({baseMipLevel: 0}); |
| let renderBundle9 = renderBundleEncoder7.finish({}); |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup32, new Uint32Array(1602), 284, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setStencilReference(140); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let querySet8 = device0.createQuerySet({type: 'occlusion', count: 2610}); |
| let renderPassEncoder24 = commandEncoder86.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 6, |
| clearValue: { r: 641.0, g: 51.59, b: -663.6, a: -0.4407, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet6, |
| }); |
| let sampler48 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 52.59, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder53.setBindGroup(2, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(1051); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer2, 'uint16', 436, 2_918); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(0, buffer45, 0, 3_103); |
| } catch {} |
| let autogeneratedBindGroupLayout32 = pipeline9.getBindGroupLayout(0); |
| let textureView78 = texture64.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer3, 'uint16', 6_030, 452); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer4, 388, 809); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 5, y: 24 }, |
| flipY: false, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 27, y: 25, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 49, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte240m', transfer: 'bt709'} }); |
| let autogeneratedBindGroupLayout33 = pipeline9.getBindGroupLayout(0); |
| let texture73 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder16.pushDebugGroup('\u{1fdfb}'); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let buffer74 = device0.createBuffer({ |
| size: 17446, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup10, new Uint32Array(551), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer5, 'uint16', 78, 75); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 23, y: 10 }, |
| flipY: false, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 213, y: 31, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 43, height: 21, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| label: '\u{1f6d3}\u73cc\ufa72\ue865\u56c2\u12a8\u{1f98d}\u{1ff0d}', |
| entries: [ |
| {binding: 378, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let textureView79 = texture1.createView({aspect: 'all', arrayLayerCount: 1}); |
| let computePassEncoder63 = commandEncoder87.beginComputePass({label: '52'}); |
| let sampler49 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 50.10}); |
| try { |
| computePassEncoder57.setBindGroup(1, bindGroup31, new Uint32Array(1829), 1_136, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(1, buffer74, 0, 1_494); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 65, y: 40, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout34 = pipeline6.getBindGroupLayout(0); |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout17]}); |
| let texture74 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 128}, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler50 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 88.18, |
| compare: 'less-equal', |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup37, new Uint32Array(3160), 191, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer5, 'uint32', 28, 59); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(5, buffer39, 0, 1_382); |
| } catch {} |
| let pipeline11 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule5, constants: {}, targets: [{format: 'r8sint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex4', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x3', offset: 944, shaderLocation: 9}, |
| {format: 'float16x4', offset: 324, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let commandEncoder88 = device0.createCommandEncoder(); |
| let querySet9 = device0.createQuerySet({type: 'occlusion', count: 476}); |
| let renderPassEncoder25 = commandEncoder88.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 13, |
| clearValue: { r: -402.3, g: 697.0, b: -427.2, a: -328.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet5, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| computePassEncoder16.popDebugGroup(); |
| } catch {} |
| let texture75 = device0.createTexture({ |
| size: {width: 216, height: 60, depthOrArrayLayers: 2}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture76 = device0.createTexture({ |
| size: [216, 60, 5], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder63.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup19, new Uint32Array(341), 189, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let autogeneratedBindGroupLayout35 = pipeline7.getBindGroupLayout(0); |
| let textureView80 = texture75.createView({aspect: 'all', arrayLayerCount: 1}); |
| let sampler51 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| lodMaxClamp: 67.54, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer2, 'uint32', 1_792, 790); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| await gc(); |
| let texture77 = device0.createTexture({ |
| size: [54], |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer38); |
| } catch {} |
| try { |
| renderPassEncoder5.pushDebugGroup('\u{1f617}'); |
| } catch {} |
| let autogeneratedBindGroupLayout36 = pipeline6.getBindGroupLayout(0); |
| let commandEncoder89 = device0.createCommandEncoder(); |
| let textureView81 = texture75.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup31, new Uint32Array(1384), 577, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer58, 'uint16', 24, 183); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout26, |
| entries: [ |
| {binding: 30, resource: textureView56}, |
| {binding: 176, resource: {buffer: buffer34, offset: 1024, size: 1032}}, |
| ], |
| }); |
| let textureView82 = texture16.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 8, arrayLayerCount: 1}); |
| let computePassEncoder64 = commandEncoder89.beginComputePass({label: '53'}); |
| let sampler52 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 95.85, |
| lodMaxClamp: 98.29, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup26, []); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup26, new Uint32Array(1370), 229, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer61, 0, 73); |
| } catch {} |
| try { |
| buffer72.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder5.popDebugGroup(); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(114, 166); |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| let renderPassEncoder26 = commandEncoder90.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 17, |
| clearValue: { r: 428.0, g: -481.8, b: 473.5, a: 419.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 96724355, |
| }); |
| try { |
| computePassEncoder64.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(297).fill(149), /* required buffer size: 297 */ |
| {offset: 297}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler53 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder59.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder59.setBindGroup(2, bindGroup33, new Uint32Array(2532), 96, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup36, new Uint32Array(3767), 789, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBlendConstant({ r: 59.08, g: 175.5, b: -156.6, a: -210.8, }); |
| } catch {} |
| let texture78 = device0.createTexture({size: [108], mipLevelCount: 1, dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.COPY_SRC}); |
| let sampler54 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 96.61, compare: 'always'}); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup14, new Uint32Array(440), 246, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle5, renderBundle2, renderBundle3]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 20, y: 10, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas2); |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'gamma28curve'} }); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout31, |
| entries: [{binding: 176, resource: {buffer: buffer65, offset: 0}}], |
| }); |
| let sampler55 = device0.createSampler({addressModeU: 'mirror-repeat', lodMinClamp: 93.20, lodMaxClamp: 97.51, compare: 'greater'}); |
| try { |
| renderPassEncoder3.setBlendConstant({ r: 662.3, g: -866.5, b: 806.6, a: 494.2, }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| externalTexture5.label = '\u0446\u{1f860}\u093b\u5dd7\u0edc\ud632\u099e\u283c\ud023\u9e84'; |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout18, |
| entries: [ |
| {binding: 176, resource: {buffer: buffer35, offset: 1536, size: 340}}, |
| {binding: 237, resource: textureView27}, |
| ], |
| }); |
| let buffer75 = device0.createBuffer({size: 7009, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder91 = device0.createCommandEncoder(); |
| let texture79 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView83 = texture76.createView({}); |
| let renderPassEncoder27 = commandEncoder91.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 208, |
| clearValue: { r: -164.3, g: 736.7, b: 489.9, a: -32.72, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| maxDrawCount: 372422332, |
| }); |
| let sampler56 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 8.474, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup36, new Uint32Array(2539), 864, 0); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| let gpuCanvasContext5 = offscreenCanvas2.getContext('webgpu'); |
| document.body.prepend(img1); |
| let img3 = await imageWithData(20, 49, '#10101010', '#20202020'); |
| let sampler57 = device0.createSampler({addressModeV: 'mirror-repeat', magFilter: 'linear', lodMaxClamp: 95.17, compare: 'greater-equal'}); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup15, new Uint32Array(1063), 99, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup13, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer66, 'uint16', 52, 219); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(18).fill(211), /* required buffer size: 18 */ |
| {offset: 18, rowsPerImage: 65}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout15, |
| entries: [{binding: 176, resource: {buffer: buffer34, offset: 1280, size: 204}}], |
| }); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let renderPassEncoder28 = commandEncoder92.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView64, |
| clearValue: { r: -332.2, g: -425.4, b: -429.4, a: 837.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 108, y: 44, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer76 = device0.createBuffer({size: 14058, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let texture80 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 25}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder19.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle6, renderBundle2, renderBundle6, renderBundle6, renderBundle2]); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let texture81 = device0.createTexture({ |
| size: [432, 120, 2], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder29 = commandEncoder93.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView47, |
| clearValue: { r: -497.7, g: 582.9, b: 199.7, a: -111.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet4, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup18, new Uint32Array(343), 56, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 70, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(84).fill(115), /* required buffer size: 84 */ |
| {offset: 84, bytesPerRow: 180}, {width: 4, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline12 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3}}); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let sampler58 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.94, |
| compare: 'less', |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup26, new Uint32Array(984), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer2, 'uint32', 2_504, 100); |
| } catch {} |
| try { |
| await buffer49.mapAsync(GPUMapMode.READ, 9952, 3656); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout37 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder94 = device0.createCommandEncoder(); |
| let textureView84 = texture27.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderPassEncoder30 = commandEncoder94.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView47, |
| clearValue: { r: 279.6, g: 630.4, b: 160.4, a: 237.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder7.beginOcclusionQuery(570); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 10, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(697).fill(151), /* required buffer size: 697 */ |
| {offset: 697, bytesPerRow: 48}, {width: 28, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 1, y: 11 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 85, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout38 = pipeline6.getBindGroupLayout(1); |
| let bindGroup44 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout25, |
| entries: [{binding: 176, resource: {buffer: buffer40, offset: 1536, size: 1004}}], |
| }); |
| let commandEncoder95 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup15, new Uint32Array(942), 179, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer54, 'uint16', 1_230, 3_955); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer38, 3_244, 105); |
| } catch {} |
| try { |
| commandEncoder95.copyTextureToTexture({ |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 58, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 6, y: 63, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 13, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer77 = device0.createBuffer({ |
| size: 15736, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let computePassEncoder65 = commandEncoder96.beginComputePass({label: '54'}); |
| let sampler59 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 82.64, |
| }); |
| try { |
| computePassEncoder58.setPipeline(pipeline7); |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer3, 'uint16', 1_256, 207); |
| } catch {} |
| try { |
| commandEncoder95.copyBufferToBuffer(buffer3, 1668, buffer49, 312, 592); |
| } catch {} |
| try { |
| commandEncoder95.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 156 */ |
| offset: 156, |
| buffer: buffer27, |
| }, { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData15 = new ImageData(32, 96); |
| let textureView85 = texture74.createView({format: 'r8sint', arrayLayerCount: 1}); |
| let computePassEncoder66 = commandEncoder95.beginComputePass({label: '55'}); |
| try { |
| computePassEncoder51.setBindGroup(2, bindGroup30); |
| } catch {} |
| let autogeneratedBindGroupLayout39 = pipeline1.getBindGroupLayout(1); |
| let sampler60 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 33.65, |
| lodMaxClamp: 89.93, |
| compare: 'equal', |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup21, new Uint32Array(3115), 1_432, 0); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| try { |
| computePassEncoder66.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline11); |
| } catch {} |
| try { |
| buffer30.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, colorSpace: 'srgb'}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup45 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [ |
| {binding: 237, resource: textureView8}, |
| {binding: 176, resource: {buffer: buffer73, offset: 0, size: 136}}, |
| ], |
| }); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout4]}); |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline11); |
| } catch {} |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let sampler61 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 95.84, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer37, 0, 477); |
| } catch {} |
| try { |
| commandEncoder97.copyBufferToBuffer(buffer27, 1520, buffer77, 2628, 888); |
| } catch {} |
| try { |
| commandEncoder97.copyTextureToBuffer({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 14 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 3549 */ |
| offset: 3549, |
| bytesPerRow: 768, |
| buffer: buffer56, |
| }, {width: 14, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder97.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout21, |
| entries: [{binding: 176, resource: {buffer: buffer38, offset: 512, size: 124}}], |
| }); |
| let textureView86 = texture75.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| let textureView87 = texture15.createView({}); |
| let computePassEncoder67 = commandEncoder97.beginComputePass({label: '56'}); |
| try { |
| computePassEncoder67.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(3, bindGroup46, new Uint32Array(2649), 37, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setViewport(87.25510064136263, 6.08207084764535, 9.69775818133272, 17.404829766317082, 0.32941816739161656, 0.6739933041909236); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer58, 'uint16', 66, 423); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 8, new Int16Array(3779), 81, 188); |
| } catch {} |
| let autogeneratedBindGroupLayout40 = pipeline4.getBindGroupLayout(1); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let computePassEncoder68 = commandEncoder98.beginComputePass({label: '57'}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: [], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle9, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer37, 'uint16', 66, 1_211); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup46, new Uint32Array(434), 66, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer66, 'uint32', 1_436, 127); |
| } catch {} |
| let bindGroup47 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout31, |
| entries: [{binding: 176, resource: {buffer: buffer60, offset: 256}}], |
| }); |
| let buffer78 = device0.createBuffer({ |
| size: 1361, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder99 = device0.createCommandEncoder(); |
| let computePassEncoder69 = commandEncoder99.beginComputePass({label: '58'}); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder69.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(0, buffer40, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'}); |
| } catch {} |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 1540}); |
| try { |
| renderPassEncoder12.insertDebugMarker('\u3b47'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer79 = device0.createBuffer({ |
| size: 2549, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundle10 = renderBundleEncoder10.finish({}); |
| let sampler62 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.20, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder49.end(); |
| } catch {} |
| try { |
| computePassEncoder68.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup28, new Uint32Array(4791), 416, 0); |
| } catch {} |
| try { |
| commandEncoder66.copyTextureToTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 332, new Int16Array(3105), 277, 0); |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder(); |
| let commandBuffer0 = commandEncoder66.finish(); |
| let computePassEncoder70 = commandEncoder100.beginComputePass({label: '59'}); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup15, new Uint32Array(2485), 1_204, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup23, new Uint32Array(3669), 718, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle7, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline3); |
| } catch {} |
| try { |
| computePassEncoder65.pushDebugGroup('\u08e7'); |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [ |
| {binding: 237, resource: textureView27}, |
| {binding: 176, resource: {buffer: buffer46, offset: 5632, size: 11500}}, |
| ], |
| }); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame10}); |
| try { |
| computePassEncoder67.setBindGroup(3, bindGroup26, new Uint32Array(699), 24, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle9, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer54, 'uint32', 1_136, 6_650); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline11); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 85, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(83).fill(55), /* required buffer size: 83 */ |
| {offset: 83}, {width: 221, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let imageData16 = new ImageData(28, 40); |
| let shaderModule7 = device0.createShaderModule({ |
| label: '\u04d5\u{1f7c6}\u0aa0\u{1fb9b}\u0790\u{1f99a}\u5ba9', |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| struct VertexOutput5 { |
| @builtin(position) f15: vec4f, |
| @location(8) f16: vec2u, |
| @location(9) @interpolate(flat, centroid) f17: f32, |
| @location(13) @interpolate(flat, centroid) f18: vec4i, |
| @location(15) f19: vec2i, |
| } |
| |
| struct FragmentOutput4 { |
| @location(0) @interpolate(flat) f0: vec2u, |
| @location(4) @interpolate(flat) f1: vec4u, |
| } |
| |
| struct T0 { |
| @size(20) f0: array<array<array<u32, 1>, 1>>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T2 { |
| @size(24) f0: array<vec4h, 2>, |
| } |
| |
| var<workgroup> vw24: array<array<vec2<bool>, 1>, 1>; |
| |
| override override16: f32; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(176) var<storage, read_write> buffer80: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1>, 9>>; |
| |
| var<workgroup> vw25: VertexOutput5; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T3 { |
| @align(16) @size(400) f0: array<array<array<u32, 1>, 1>, 50>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn fn0() -> vec2h { |
| var out: vec2h; |
| out += vec2h(inverseSqrt(f16(unconst_f16(20510.2)))); |
| let vf90: vec4i = extractBits(vec4i(unconst_i32(-103), unconst_i32(-85), unconst_i32(-275), unconst_i32(32)), u32(unconst_u32(213)), u32(unconst_u32(14))); |
| var vf91: vec2i = firstTrailingBit(vec2i(unconst_i32(-86), unconst_i32(275))); |
| vf91 = firstTrailingBit(vec2i(unconst_i32(-10), unconst_i32(68))); |
| var vf92: f16 = inverseSqrt(f16(unconst_f16(2969.9))); |
| out += vec2h(vf92); |
| var vf93: vec2i = firstTrailingBit(vec2i(tan(vec3h(unconst_f16(1344.0), unconst_f16(491.5), unconst_f16(4501.9))).zy)); |
| let vf94: u32 = dot4U8Packed(u32(unconst_u32(3)), u32(unconst_u32(11))); |
| vf93 += vec2i(vf90[u32(unconst_u32(548))]); |
| let vf95: f16 = inverseSqrt(f16(unconst_f16(6799.3))); |
| vf92 -= vec2h(vf91)[0]; |
| var vf96: u32 = vf94; |
| vf91 &= vf91; |
| let vf97: vec2i = select(vec2i(unconst_i32(44), unconst_i32(108)), vec2i(unconst_i32(487), unconst_i32(37)), vec2<bool>(bool(vf93[u32(unconst_u32(2))]))); |
| vf92 += f16(vf90[3]); |
| vf91 |= extractBits(vec4i(unconst_i32(41), unconst_i32(497), unconst_i32(365), unconst_i32(27)), u32(unconst_u32(277)), u32(unconst_u32(69))).ar; |
| var vf98: i32 = vf91[u32(unconst_u32(107))]; |
| vf92 *= f16(vf94); |
| let vf99: u32 = vf94; |
| let vf100: vec2i = firstTrailingBit(vec2i(unconst_i32(144), unconst_i32(162))); |
| var vf101: f32 = override16; |
| return out; |
| _ = override16; |
| } |
| |
| struct T1 { |
| f0: u32, |
| @size(16) f1: array<mat3x2h>, |
| } |
| |
| @vertex |
| fn vertex8(@location(0) @interpolate(flat, sample) a0: i32) -> VertexOutput5 { |
| var out: VertexOutput5; |
| out.f15 -= vec4f(f32(cos(f16(unpack4x8unorm(bitcast<u32>(a0))[0])))); |
| out.f16 = vec2u(dot4U8Packed(u32(unconst_u32(34)), u32(unconst_u32(64)))); |
| fn0(); |
| var vf102: vec3f = cross(vec3f(unconst_f32(0.1610), unconst_f32(0.2467), unconst_f32(0.02000)), fract(vec2f(unconst_f32(-0.07339), unconst_f32(0.02255))).rgg); |
| let vf103: f32 = override16; |
| var vf104 = fn0(); |
| fn0(); |
| out = VertexOutput5(vec4f(vf104.yyxx), vec2u(vf104), bitcast<f32>(vf104), vec4i(vf104.ggrr), vec2i(vf104)); |
| fn0(); |
| var vf105 = fn0(); |
| let vf106: f32 = exp2(f32(unconst_f32(0.7737))); |
| var vf107 = fn0(); |
| vf107 = bitcast<vec2h>(vf102[u32(unconst_u32(369))]); |
| var vf108 = fn0(); |
| vf102 = vf102; |
| let vf109: f32 = exp2(f32(unconst_f32(0.3087))); |
| fn0(); |
| var vf110 = fn0(); |
| let vf111: f32 = determinant(mat3x3f()); |
| return out; |
| _ = override16; |
| } |
| |
| @fragment |
| fn fragment4() -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| let ptr45: ptr<storage, array<f16, 1>, read_write> = &buffer80[u32(unconst_u32(251))][u32(unconst_u32(169))][u32(unconst_u32(808))][0][u32(buffer80[arrayLength(&buffer80)][u32(unconst_u32(249))][0][u32(unconst_u32(27))][0][0][0])][0]; |
| let ptr46: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read_write> = &buffer80[u32(unconst_u32(779))][8][u32(unconst_u32(27))][u32((*&buffer80)[arrayLength(&(*&buffer80))][8][u32(unconst_u32(281))][0][u32(unconst_u32(149))][u32(unconst_u32(125))][u32(unconst_u32(92))])]; |
| let ptr47: ptr<storage, array<array<f16, 1>, 1>, read_write> = &(*&buffer80)[arrayLength(&(*&buffer80))][8][0][0][0]; |
| let ptr48: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read_write> = &(*&buffer80)[u32(buffer80[arrayLength(&buffer80)][8][0][0][0][u32(unconst_u32(1))][u32(unconst_u32(3))])][u32(unconst_u32(46))][0][0]; |
| let ptr49: ptr<storage, f16, read_write> = &buffer80[arrayLength(&buffer80)][u32(unconst_u32(12))][u32(unconst_u32(106))][0][u32(unconst_u32(121))][0][0]; |
| let vf112: u32 = arrayLength(&(*&buffer80)); |
| let ptr50: ptr<storage, f16, read_write> = &(*&buffer80)[arrayLength(&(*&buffer80))][u32(unconst_u32(49))][0][u32((*&buffer80)[arrayLength(&(*&buffer80))][u32(unconst_u32(54))][u32(unconst_u32(22))][u32(unconst_u32(93))][0][0][0])][u32(unconst_u32(102))][0][0]; |
| buffer80[u32(unconst_u32(234))][u32(unconst_u32(23))][u32(unconst_u32(274))][u32(unconst_u32(28))][u32(unconst_u32(36))][u32(unconst_u32(120))][u32(unconst_u32(1))] = buffer80[u32(unconst_u32(263))][8][u32(unconst_u32(33))][0][u32(unconst_u32(240))][0][0]; |
| out.f1 >>= vec4u(u32((*ptr48)[u32(unconst_u32(273))][0][0])); |
| let ptr51: ptr<storage, f16, read_write> = &(*&buffer80)[u32(unconst_u32(110))][u32(unconst_u32(195))][0][0][0][u32(unconst_u32(107))][0]; |
| let ptr52: ptr<storage, array<f16, 1>, read_write> = &(*&buffer80)[arrayLength(&(*&buffer80))][8][u32(unconst_u32(314))][0][0][0]; |
| let ptr53: ptr<storage, f16, read_write> = &buffer80[arrayLength(&buffer80)][u32(unconst_u32(3))][0][u32(unconst_u32(103))][u32(unconst_u32(288))][u32(unconst_u32(76))][0]; |
| out.f0 ^= vec2u(u32(buffer80[arrayLength(&buffer80)][8][u32(unconst_u32(125))][u32(unconst_u32(291))][u32(unconst_u32(14))][0][0])); |
| let ptr54: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read_write> = &buffer80[u32(unconst_u32(194))][u32(unconst_u32(19))][0][0]; |
| let ptr55: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1>, read_write> = &(*&buffer80)[u32(unconst_u32(83))][u32(unconst_u32(162))]; |
| let ptr56: ptr<storage, f16, read_write> = &(*&buffer80)[u32(unconst_u32(33))][8][u32(unconst_u32(46))][0][u32(unconst_u32(21))][0][u32(unconst_u32(189))]; |
| out.f1 = vec4u(u32((*&buffer80)[u32(unconst_u32(89))][u32(unconst_u32(33))][u32(unconst_u32(162))][0][0][0][0])); |
| let ptr57: ptr<storage, array<f16, 1>, read_write> = &buffer80[arrayLength(&buffer80)][8][u32(unconst_u32(250))][u32(unconst_u32(91))][0][0]; |
| out = FragmentOutput4(vec2u(u32((*&buffer80)[arrayLength(&(*&buffer80))][u32(unconst_u32(1))][0][u32(unconst_u32(24))][0][u32(unconst_u32(207))][0])), vec4u(u32((*&buffer80)[arrayLength(&(*&buffer80))][u32(unconst_u32(1))][0][u32(unconst_u32(24))][0][u32(unconst_u32(207))][0]))); |
| return out; |
| _ = buffer80; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute6() { |
| vw24[u32(unconst_u32(348))][0] = vec2<bool>((*&vw24)[u32(unconst_u32(157))][0][u32(unconst_u32(176))]); |
| }`, |
| }); |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let textureView88 = texture71.createView({format: 'r8sint', arrayLayerCount: 1}); |
| let sampler63 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 62.64, |
| lodMaxClamp: 95.96, |
| }); |
| try { |
| computePassEncoder70.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 2004, new Float32Array(40), 10, 12); |
| } catch {} |
| let promise12 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}}); |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| @align(8) f0: array<mat2x2h, 1>, |
| } |
| |
| @group(1) @binding(237) var st22: texture_storage_1d<r32float, read_write>; |
| |
| struct T2 { |
| @size(20) f0: array<array<atomic<i32>, 1>>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @id(45279) override override17: f16 = 2671.1; |
| |
| struct FragmentOutput5 { |
| @location(0) f0: vec2i, |
| } |
| |
| fn fn2() -> array<array<T0, 1>, 2> { |
| var out: array<array<T0, 1>, 2>; |
| vp7 = modf(smoothstep(vec3f(unconst_f32(0.1106), unconst_f32(0.1139), unconst_f32(0.1133)), vec3f(unconst_f32(0.04148), unconst_f32(0.5525), unconst_f32(0.2429)), vec3f(unconst_f32(0.02669), unconst_f32(0.1328), unconst_f32(0.1763))).xzzx); |
| let ptr60: ptr<storage, array<f16, 1>, read_write> = &(*&buffer81)[2][u32(unconst_u32(244))]; |
| vp7.fract -= vec4f(f32((*&buffer81)[u32(unconst_u32(238))][2][u32(unconst_u32(27))])); |
| buffer81[u32(unconst_u32(130))][u32(unconst_u32(337))][u32(unconst_u32(170))] *= ceil(f16(unconst_f16(7656.0))); |
| vp7.whole = vec4f(f32(buffer81[u32(unconst_u32(52))][u32(unconst_u32(179))][0])); |
| buffer81[pack4x8snorm(vp7.fract)][u32(unconst_u32(39))][u32(unconst_u32(278))] += buffer81[2][u32(unconst_u32(19))][0]; |
| let ptr61: ptr<storage, array<array<f16, 1>, 3>, read_write> = &buffer81[u32(unconst_u32(32))]; |
| let ptr62: ptr<storage, array<f16, 1>, read_write> = &(*&buffer81)[u32(unconst_u32(520))][2]; |
| buffer81[u32(unconst_u32(59))][u32(unconst_u32(227))][u32(unconst_u32(200))] -= refract(vec3h(unconst_f16(2354.4), unconst_f16(-11053.1), unconst_f16(10073.4)), vec3h(unconst_f16(-35776.8), unconst_f16(3063.3), unconst_f16(17354.6)), f16(unconst_f16(48.83)))[1]; |
| let ptr63: ptr<storage, f16, read_write> = &buffer81[u32(buffer81[2][2][u32(unconst_u32(2))])][u32(unconst_u32(50))][u32(unconst_u32(76))]; |
| let ptr64: ptr<storage, f16, read_write> = &(*ptr62)[0]; |
| vp7 = modf(vec4f(bitcast<f32>(dot4U8Packed(u32(unconst_u32(70)), u32(unconst_u32(7)))))); |
| vp7 = modf(vec4f(f32((*&buffer81)[u32(unconst_u32(259))][u32(unconst_u32(81))][u32(unconst_u32(78))]))); |
| var vf115: f16 = cosh(f16(unconst_f16(6387.8))); |
| vp7 = modf(vp7.fract); |
| let ptr65: ptr<storage, array<f16, 1>, read_write> = &(*ptr62); |
| return out; |
| _ = buffer81; |
| } |
| |
| var<private> vp7 = modf(vec4f(0.2263, 0.02334, 0.09898, 0.3501)); |
| |
| fn fn1() -> vec4<bool> { |
| var out: vec4<bool>; |
| let vf114: i32 = atomicLoad(&(*&vw28)[0][u32(unconst_u32(76))]); |
| textureBarrier(); |
| vw27.f0[u32(unconst_u32(20))] = mat2x2h(f16(atomicLoad(&vw29[62])), f16(atomicLoad(&vw29[62])), f16(atomicLoad(&vw29[62])), f16(atomicLoad(&vw29[62]))); |
| buffer81[u32(unconst_u32(334))][u32(unconst_u32(202))][u32((*&buffer81)[u32(unconst_u32(46))][2][0])] = (*&buffer81)[2][2][0]; |
| textureStore(st21, vec2i(unconst_i32(289), unconst_i32(379)), i32(unconst_i32(128)), vec4i(vec4i(firstTrailingBit(vec4u(unconst_u32(148), unconst_u32(355), unconst_u32(258), unconst_u32(159)))))); |
| storageBarrier(); |
| out = vec4<bool>(bool(atomicLoad(&vw29[u32(unconst_u32(286))]))); |
| out = vec4<bool>(bool(atomicExchange(&vw28[0][u32(unconst_u32(412))], i32(unconst_i32(11))))); |
| atomicMin(&vw28[u32(unconst_u32(76))][u32(unconst_u32(32))], i32(unconst_i32(237))); |
| return out; |
| _ = buffer81; |
| _ = st21; |
| } |
| |
| var<workgroup> vw27: T0; |
| |
| fn fn0(a0: ptr<function, vec4<bool>>, a1: ptr<storage, FragmentOutput5, read_write>) { |
| let ptr58: ptr<storage, array<f16, 1>, read_write> = &buffer81[u32(unconst_u32(79))][u32(unconst_u32(210))]; |
| (*a1) = FragmentOutput5(vec2i(i32(buffer81[u32(unconst_u32(199))][u32(unconst_u32(107))][bitcast<u32>(smoothstep(vec2h(unconst_f16(12706.7), unconst_f16(9795.6)), vec2h(unconst_f16(-2776.5), unconst_f16(1982.9)), vec2h(unconst_f16(17073.7), unconst_f16(2989.4))))]))); |
| let vf113: u32 = pack4x8snorm(vec4f(unconst_f32(-0.00616), unconst_f32(0.2559), unconst_f32(0.07100), unconst_f32(0.06013))); |
| (*a0) = vec4<bool>(bool((*ptr58)[0])); |
| buffer81[u32(unconst_u32(167))][u32(unconst_u32(167))][u32(unconst_u32(46))] *= smoothstep(vec2h(unconst_f16(3355.5), unconst_f16(417.6)), vec2h(unconst_f16(24350.5), unconst_f16(506.8)), vec2h(unconst_f16(15492.9), unconst_f16(12036.0)))[1]; |
| buffer81[u32(unconst_u32(4))][2][u32(unconst_u32(11))] *= (*&buffer81)[2][2][u32(unconst_u32(246))]; |
| let ptr59: ptr<storage, array<f16, 1>, read_write> = &buffer81[u32(unconst_u32(268))][2]; |
| _ = buffer81; |
| } |
| |
| @group(1) @binding(138) var tex8: texture_2d<i32>; |
| |
| var<workgroup> vw28: array<array<atomic<i32>, 13>, 1>; |
| |
| struct T3 { |
| @size(24) f0: array<mat2x4h>, |
| } |
| |
| var<workgroup> vw29: array<atomic<u32>, 63>; |
| |
| struct T1 { |
| @size(20) f0: array<u32>, |
| } |
| |
| struct T4 { |
| @size(24) f0: array<T0>, |
| } |
| |
| @group(0) @binding(30) var st19: texture_storage_2d_array<r32sint, read_write>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(237) var st20: texture_storage_1d<r32float, read_write>; |
| |
| var<workgroup> vw26: vec2h; |
| |
| struct VertexOutput6 { |
| @builtin(position) f20: vec4f, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(1) @binding(176) var<storage, read_write> buffer81: array<array<array<f16, 1>, 3>, 3>; |
| |
| @group(0) @binding(138) var tex7: texture_2d<i32>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| override override18: u32; |
| |
| @group(1) @binding(30) var st21: texture_storage_2d_array<r32sint, read_write>; |
| |
| @vertex |
| fn vertex9(@location(10) @interpolate(flat, center) a0: vec4u) -> VertexOutput6 { |
| var out: VertexOutput6; |
| out = VertexOutput6(vec4f(inverseSqrt(vec3f(sqrt(vec3h(unconst_f16(1337.6), unconst_f16(9345.7), unconst_f16(8901.3))))[1]))); |
| out = VertexOutput6(unpack2x16unorm(u32(unconst_u32(8))).yyxy); |
| let vf116: vec4h = mix(vec4h(unconst_f16(-5125.1), unconst_f16(45085.9), unconst_f16(1803.5), unconst_f16(28096.3)), vec4h(unconst_f16(-3240.1), unconst_f16(3619.5), unconst_f16(14259.2), unconst_f16(24638.4)), vec4h(unconst_f16(6113.6), unconst_f16(40583.0), unconst_f16(5570.9), unconst_f16(577.7))); |
| var vf117: vec4i = sign(vec4i(unconst_i32(61), unconst_i32(239), unconst_i32(82), unconst_i32(83))); |
| var vf118: vec4f = abs(vec4f(unconst_f32(0.00276), unconst_f32(0.07918), unconst_f32(0.04439), unconst_f32(0.08892))); |
| let vf119: f32 = vf118[u32(unconst_u32(265))]; |
| let vf120: vec4i = firstTrailingBit(vec4i(vp7.whole)); |
| vf117 = bitcast<vec4i>(a0); |
| vf118 = vp7.whole; |
| vf117 = vec4i(i32(fma(f16(unconst_f16(-5792.4)), f16(unconst_f16(-20038.2)), f16(unconst_f16(1129.0))))); |
| var vf121: f16 = override17; |
| return out; |
| _ = override17; |
| } |
| |
| @fragment |
| fn fragment5() -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| buffer81[u32(unconst_u32(2))][u32(unconst_u32(290))][u32(unconst_u32(253))] += (*&buffer81)[2][u32(unconst_u32(28))][u32(unconst_u32(63))]; |
| textureStore(st22, i32(unconst_i32(53)), vec4f(vec4f(unconst_f32(0.02747), unconst_f32(0.08018), unconst_f32(0.5365), unconst_f32(0.02545)))); |
| var vf122: vec2f = sin(vec2f(f32((*&buffer81)[u32(unconst_u32(192))][u32(unconst_u32(143))][0]))); |
| textureStore(st20, i32(unconst_i32(-237)), vec4f(vec4f(unconst_f32(0.01840), unconst_f32(0.01212), unconst_f32(0.3112), unconst_f32(0.08604)))); |
| out.f0 += vec2i(log(vec4f(unconst_f32(0.1431), unconst_f32(0.3127), unconst_f32(0.07128), unconst_f32(0.1668))).ar); |
| buffer81[u32(unconst_u32(28))][u32(unconst_u32(34))][u32(unconst_u32(43))] = f16(asinh(vec4f(unconst_f32(0.3563), unconst_f32(0.3430), unconst_f32(0.02306), unconst_f32(0.3779))).z); |
| textureStore(st22, i32(unconst_i32(60)), vec4f(textureLoad(st22, i32(unconst_i32(-31))))); |
| var vf123: vec2u = textureDimensions(tex7); |
| let vf124: vec4i = textureLoad(tex8, vec2i(unconst_i32(404), unconst_i32(178)), i32(unconst_i32(396))); |
| out.f0 ^= vec2i(i32((*&buffer81)[2][2][0])); |
| textureStore(st22, i32(unconst_i32(-327)), vec4f(vec4f(unconst_f32(0.09525), unconst_f32(0.03221), unconst_f32(0.1033), unconst_f32(0.1243)))); |
| let ptr66: ptr<storage, array<array<f16, 1>, 3>, read_write> = &(*&buffer81)[2]; |
| vf122 += sin(vec2f(vf124.ab)); |
| let ptr67: ptr<storage, f16, read_write> = &buffer81[2][2][0]; |
| var vf125 = fn2(); |
| vp7.fract = vec4f(f32(vf125[u32(unconst_u32(756))][u32(unconst_u32(43))].f0[0][u32(unconst_u32(131))][u32(unconst_u32(261))])); |
| return out; |
| _ = buffer81; |
| _ = st22; |
| _ = tex7; |
| _ = tex8; |
| _ = st20; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute7() { |
| let vf126: u32 = atomicLoad(&vw29[u32((*&buffer81)[2][2][0])]); |
| let ptr68: ptr<storage, f16, read_write> = &(*&buffer81)[2][u32(unconst_u32(371))][0]; |
| buffer81[u32(unconst_u32(32))][u32(unconst_u32(156))][u32(unconst_u32(49))] = vec4h(fract(vec4f(unconst_f32(0.2838), unconst_f32(0.06896), unconst_f32(0.2347), unconst_f32(0.08286))))[1]; |
| let vf127: vec4i = textureLoad(st19, vec2i(unconst_i32(358), unconst_i32(35)), i32(unconst_i32(404))); |
| vp7.whole = vec4f(select(vec4u(unconst_u32(130), unconst_u32(103), unconst_u32(130), unconst_u32(37)), vec4u(log(vec2h(unconst_f16(2435.6), unconst_f16(9678.1))).yyxx), vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(false)))); |
| var vf128 = fn1(); |
| textureStore(st21, vec2i(unconst_i32(109), unconst_i32(203)), i32(unconst_i32(221)), vec4i(vec4i(unconst_i32(209), unconst_i32(11), unconst_i32(236), unconst_i32(250)))); |
| let ptr69: ptr<workgroup, atomic<i32>> = &vw28[0][12]; |
| atomicSub(&vw28[0][u32(unconst_u32(21))], i32(unconst_i32(69))); |
| vw27.f0[u32(unconst_u32(484))] = mat2x2h(buffer81[u32(unconst_u32(250))][u32(unconst_u32(839))][0], buffer81[u32(unconst_u32(250))][u32(unconst_u32(839))][0], buffer81[u32(unconst_u32(250))][u32(unconst_u32(839))][0], buffer81[u32(unconst_u32(250))][u32(unconst_u32(839))][0]); |
| _ = buffer81; |
| _ = st21; |
| _ = st19; |
| }`, |
| }); |
| let buffer82 = device0.createBuffer({ |
| size: 12976, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder102 = device0.createCommandEncoder(); |
| let computePassEncoder71 = commandEncoder101.beginComputePass({label: '60'}); |
| let sampler64 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.03, |
| compare: 'never', |
| maxAnisotropy: 19, |
| }); |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup8, new Uint32Array(901), 74, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer82, 'uint32', 836, 2_720); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout17, |
| entries: [ |
| {binding: 237, resource: textureView27}, |
| {binding: 176, resource: {buffer: buffer46, offset: 512, size: 8128}}, |
| ], |
| }); |
| let computePassEncoder72 = commandEncoder102.beginComputePass({label: '61'}); |
| try { |
| computePassEncoder48.setBindGroup(2, bindGroup17, new Uint32Array(4381), 833, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup22, new Uint32Array(402), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer54, 'uint32', 472, 3_007); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(1, buffer34, 0, 982); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer54, 3908, new BigUint64Array(29096), 19552, 260); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img3, |
| origin: { x: 1, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 1, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| renderPassEncoder9.executeBundles([renderBundle9, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(3, buffer3, 252, 1_618); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 0, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 4, y: 43, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas2); |
| let img4 = await imageWithData(51, 91, '#10101010', '#20202020'); |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline11); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt709', transfer: 'bt1361ExtendedColourGamut'} }); |
| let autogeneratedBindGroupLayout41 = pipeline10.getBindGroupLayout(0); |
| let texture82 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView89 = texture25.createView({dimension: '2d', baseArrayLayer: 0}); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup11, new Uint32Array(2533), 1_129, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, undefined); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| try { |
| adapter1.label = '\u{1ff08}\ufd35\u000e\u03b6\u0df5\u38e0'; |
| } catch {} |
| let sampler65 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder72.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer78, 'uint16', 276, 104); |
| } catch {} |
| document.body.append(canvas1); |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpteRp431', transfer: 'bt2020_10bit'} }); |
| let commandEncoder103 = device0.createCommandEncoder(); |
| let texture83 = device0.createTexture({ |
| size: [54, 15, 274], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView90 = texture3.createView({aspect: 'all', arrayLayerCount: 1}); |
| let computePassEncoder73 = commandEncoder103.beginComputePass({label: '62'}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup34, new Uint32Array(2136), 143, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setScissorRect(5, 2, 5, 13); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer31, 'uint16', 96, 102); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await buffer30.mapAsync(GPUMapMode.WRITE, 0, 1204); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u0ab7'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 2808, new Int16Array(4483), 933, 572); |
| } catch {} |
| let autogeneratedBindGroupLayout42 = pipeline5.getBindGroupLayout(0); |
| let buffer83 = device0.createBuffer({size: 8165, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView91 = texture83.createView({}); |
| let textureView92 = texture10.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder22.setBindGroup(1, bindGroup41, []); |
| } catch {} |
| try { |
| computePassEncoder61.setBindGroup(1, bindGroup30, new Uint32Array(752), 122, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer55, 'uint32', 1_652, 301); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(3, buffer45); |
| } catch {} |
| let imageData17 = new ImageData(40, 4); |
| let autogeneratedBindGroupLayout43 = pipeline8.getBindGroupLayout(0); |
| let buffer84 = device0.createBuffer({ |
| size: 21452, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let texture84 = device0.createTexture({ |
| size: [108, 30, 2], |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView93 = texture19.createView({}); |
| let sampler66 = device0.createSampler({ |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.27, |
| compare: 'equal', |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder71.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer77); |
| } catch {} |
| try { |
| commandEncoder104.copyBufferToTexture({ |
| /* bytesInLastRow: 40 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 184 */ |
| offset: 184, |
| buffer: buffer31, |
| }, { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 40, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame11, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let commandEncoder105 = device0.createCommandEncoder(); |
| let texture85 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture86 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder31 = commandEncoder105.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView64, |
| clearValue: { r: 837.0, g: -144.9, b: 305.6, a: -690.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet4, |
| }); |
| try { |
| computePassEncoder73.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(3, bindGroup30, new Uint32Array(3718), 218, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setViewport(47.59399421445689, 29.640233640582522, 13.650377557879237, 0.06277780497502783, 0.1560381242762463, 0.6662670795190456); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer84, 'uint32', 504, 6_817); |
| } catch {} |
| try { |
| commandEncoder104.copyTextureToTexture({ |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 44, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 59, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder31.insertDebugMarker('\u{1ff19}'); |
| } catch {} |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let texture87 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder32 = commandEncoder104.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView85, |
| depthSlice: 30, |
| clearValue: { r: 63.49, g: -447.8, b: 319.5, a: -323.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 13145968, |
| }); |
| try { |
| computePassEncoder70.setBindGroup(2, bindGroup30, new Uint32Array(745), 141, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup31, new Uint32Array(713), 403, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData5, |
| origin: { x: 11, y: 16 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 169, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 30, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture1.label = '\u{1fead}\ud2c0\u3e43\u74c3\u35e8\u8f85\u08e5\u8e36'; |
| } catch {} |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 269, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture88 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| mipLevelCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder33 = commandEncoder106.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView28, |
| depthSlice: 20, |
| clearValue: { r: 40.26, g: -356.5, b: 243.6, a: 646.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup32, []); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(21); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle0, renderBundle5, renderBundle7, renderBundle8, renderBundle9]); |
| } catch {} |
| let pipeline13 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| constants: {1_579: 0}, |
| targets: [{format: 'r8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule7, |
| constants: {override16: 0}, |
| buffers: [{arrayStride: 0, attributes: [{format: 'sint16x2', offset: 84, shaderLocation: 0}]}], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'back', unclippedDepth: true}, |
| }); |
| try { |
| await promise13; |
| } catch {} |
| await gc(); |
| let bindGroup50 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 176, resource: {buffer: buffer34, offset: 256, size: 1480}}], |
| }); |
| let buffer85 = device0.createBuffer({ |
| size: 29623, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder107 = device0.createCommandEncoder(); |
| let texture89 = device0.createTexture({ |
| size: {width: 216, height: 60, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup33, new Uint32Array(1578), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer2, 'uint16', 368, 416); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(0, buffer36, 0, 2_348); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| let texture90 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| sampleCount: 1, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView94 = texture72.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder74 = commandEncoder107.beginComputePass({label: '63'}); |
| try { |
| computePassEncoder74.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(2330), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.end(); |
| } catch {} |
| try { |
| renderPassEncoder30.setScissorRect(9, 1, 20, 2); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer28, 'uint16', 742, 2_633); |
| } catch {} |
| let gpuCanvasContext6 = canvas3.getContext('webgpu'); |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let texture91 = device0.createTexture({ |
| size: [108, 30, 2], |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder75 = commandEncoder108.beginComputePass({label: '\u6be1\u{1fd5e}\ufb76\u28e1\u{1f8bc}\ud7c7\u6c36\u746a\u{1ffb3}'}); |
| try { |
| commandEncoder109.clearBuffer(buffer29, 1600, 452); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 0, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 9, y: 19, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageBitmap4 = await createImageBitmap(img2); |
| let texture92 = device0.createTexture({ |
| size: [216, 60, 2], |
| mipLevelCount: 1, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView95 = texture1.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1}); |
| let computePassEncoder76 = commandEncoder80.beginComputePass({label: '64'}); |
| let sampler67 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 77.58}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame18}); |
| try { |
| computePassEncoder61.setPipeline(pipeline10); |
| } catch {} |
| try { |
| computePassEncoder75.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(1); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer32, 4_268); |
| } catch {} |
| try { |
| commandEncoder109.resolveQuerySet(querySet1, 206, 116, buffer28, 768); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 8, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(302).fill(253), /* required buffer size: 302 */ |
| {offset: 302}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let texture93 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| mipLevelCount: 3, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture94 = device0.createTexture({ |
| size: [216, 60, 2], |
| mipLevelCount: 6, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let texture95 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| computePassEncoder76.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup30, new Uint32Array(393), 113, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.insertDebugMarker('\u{1f9ec}'); |
| } catch {} |
| try { |
| adapter1.label = '\u02a8\u0704\u0c38\u0e19\uf05e\ue035\uf035\u1a7b\u0f6b'; |
| } catch {} |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let commandBuffer1 = commandEncoder110.finish(); |
| let texture96 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture97 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| mipLevelCount: 3, |
| format: 'astc-6x5-unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView96 = texture78.createView({aspect: 'all'}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer10, 'uint32', 216, 1_032); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 30, resource: textureView9}, |
| {binding: 176, resource: {buffer: buffer79, offset: 0, size: 560}}, |
| {binding: 473, resource: sampler13}, |
| {binding: 237, resource: textureView15}, |
| {binding: 138, resource: textureView52}, |
| ], |
| }); |
| let texture98 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 22}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder77 = commandEncoder111.beginComputePass({label: '65'}); |
| try { |
| computePassEncoder69.setBindGroup(1, bindGroup3, new Uint32Array(1305), 125, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer37, 'uint32', 0, 72); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer20, 0); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 176, resource: {buffer: buffer47, offset: 2048, size: 456}}], |
| }); |
| let textureView97 = texture98.createView({dimension: 'cube'}); |
| let texture99 = device0.createTexture({ |
| size: [8, 8, 22], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup15, new Uint32Array(566), 123, 0); |
| } catch {} |
| try { |
| computePassEncoder77.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup28, new Uint32Array(386), 76, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(99); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer32, 'uint32', 1_260, 28); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer38, 4_428, 196); |
| } catch {} |
| let arrayBuffer0 = buffer49.getMappedRange(10696, 360); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img2); |
| let autogeneratedBindGroupLayout44 = pipeline4.getBindGroupLayout(0); |
| let bindGroup53 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout28, |
| entries: [{binding: 176, resource: {buffer: buffer78, offset: 256, size: 116}}], |
| }); |
| let buffer86 = device0.createBuffer({size: 29565, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView98 = texture84.createView({dimension: '2d'}); |
| let renderPassEncoder34 = commandEncoder109.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView52, |
| clearValue: { r: 328.4, g: -196.8, b: -97.25, a: -30.88, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder61.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder51.setBindGroup(1, bindGroup52, new Uint32Array(388), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(7, buffer18, 324); |
| } catch {} |
| document.body.prepend(canvas0); |
| try { |
| externalTexture5.label = '\u0fb4\u4c68\u0c34\u{1fa3c}\u{1fcfb}\uf1b1'; |
| } catch {} |
| let autogeneratedBindGroupLayout45 = pipeline8.getBindGroupLayout(0); |
| try { |
| computePassEncoder36.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(5, buffer36, 0, 585); |
| } catch {} |
| let buffer87 = device0.createBuffer({ |
| size: 3334, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let texture100 = device0.createTexture({size: [8], mipLevelCount: 1, dimension: '1d', format: 'rg16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder28.setBlendConstant({ r: 410.6, g: 394.1, b: -963.0, a: -671.0, }); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(2, buffer79, 44, 272); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(14).fill(164), /* required buffer size: 14 */ |
| {offset: 14, bytesPerRow: 329, rowsPerImage: 33}, {width: 24, height: 23, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas4 = document.createElement('canvas'); |
| let texture101 = device0.createTexture({ |
| size: {width: 216, height: 60, depthOrArrayLayers: 2}, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup10, new Uint32Array(5584), 3_404, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 32, new Int16Array(7170), 1198, 192); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData18 = new ImageData(16, 36); |
| let buffer88 = device0.createBuffer({size: 427, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup48, []); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer73, 'uint32', 108, 163); |
| } catch {} |
| let arrayBuffer1 = buffer49.getMappedRange(9952, 204); |
| try { |
| buffer83.unmap(); |
| } catch {} |
| try { |
| computePassEncoder18.insertDebugMarker('\u0239'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let autogeneratedBindGroupLayout46 = pipeline8.getBindGroupLayout(0); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline11); |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| let computePassEncoder78 = commandEncoder112.beginComputePass({label: '66'}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup33, new Uint32Array(283), 4, 0); |
| } catch {} |
| try { |
| computePassEncoder78.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup14, new Uint32Array(732), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer18, 'uint16', 2_876, 300); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline11); |
| } catch {} |
| let texture102 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 459}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder30.setBindGroup(1, bindGroup18, new Uint32Array(404), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline5); |
| } catch {} |
| try { |
| computePassEncoder65.popDebugGroup(); |
| } catch {} |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder69.setBindGroup(3, bindGroup25, new Uint32Array(1093), 237, 0); |
| } catch {} |
| let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let imageData19 = new ImageData(12, 4); |
| let bindGroup54 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout31, |
| entries: [{binding: 176, resource: {buffer: buffer20, offset: 512, size: 740}}], |
| }); |
| let textureView99 = texture83.createView({}); |
| let computePassEncoder79 = commandEncoder113.beginComputePass({label: '67'}); |
| try { |
| renderPassEncoder26.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| await shaderModule8.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 1, y: 2, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(106_434).fill(73), /* required buffer size: 106_434 */ |
| {offset: 174, bytesPerRow: 115, rowsPerImage: 12}, {width: 0, height: 0, depthOrArrayLayers: 78}); |
| } catch {} |
| let pipeline15 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x1d1f7d67}, |
| fragment: { |
| module: shaderModule7, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth16unorm', |
| depthWriteEnabled: true, |
| depthCompare: 'greater-equal', |
| stencilBack: {failOp: 'keep'}, |
| stencilReadMask: 1050357281, |
| stencilWriteMask: 1602636735, |
| depthBias: 874913331, |
| depthBiasClamp: 264.3395917191769, |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 644, |
| stepMode: 'vertex', |
| attributes: [{format: 'uint32', offset: 116, shaderLocation: 3}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let commandEncoder114 = device0.createCommandEncoder(); |
| let computePassEncoder80 = commandEncoder114.beginComputePass({label: '68'}); |
| try { |
| computePassEncoder79.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup44, new Uint32Array(883), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setBlendConstant({ r: 875.0, g: -306.0, b: -635.3, a: -107.4, }); |
| } catch {} |
| try { |
| renderPassEncoder24.setViewport(150.9864444626926, 40.048846379796984, 12.336433650152205, 6.069353044002, 0.7583287400622831, 0.9657663515350234); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(6, buffer77, 7_500, 922); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 28, new BigUint64Array(12180), 32, 8); |
| } catch {} |
| let buffer89 = device0.createBuffer({ |
| size: 210, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView100 = texture92.createView({aspect: 'all', arrayLayerCount: 1}); |
| let sampler68 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 31.14, |
| lodMaxClamp: 44.19, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(3, bindGroup54, new Uint32Array(183), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer83, 'uint32', 1_856, 545); |
| } catch {} |
| let arrayBuffer2 = buffer49.getMappedRange(11264, 248); |
| let autogeneratedBindGroupLayout47 = pipeline2.getBindGroupLayout(1); |
| let textureView101 = texture52.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder80.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup21, new Uint32Array(805), 31, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline13); |
| } catch {} |
| let textureView102 = texture98.createView({dimension: 'cube', baseArrayLayer: 3}); |
| let texture103 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder10.dispatchWorkgroups(1, 1); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup25, new Uint32Array(316), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setStencilReference(373); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer84, 'uint32', 448, 3_583); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 436, new Float32Array(209), 107); |
| } catch {} |
| let texture104 = device0.createTexture({ |
| size: {width: 108, height: 30, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView103 = texture63.createView({dimension: '2d'}); |
| try { |
| renderPassEncoder1.setVertexBuffer(5, buffer4, 1_540, 587); |
| } catch {} |
| try { |
| buffer26.unmap(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let buffer90 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView104 = texture5.createView({}); |
| let sampler69 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'greater', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle5, renderBundle3, renderBundle9, renderBundle1, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline3); |
| } catch {} |
| let buffer91 = device0.createBuffer({size: 11081, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup53); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer48, 976); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer55, 'uint32', 3_836, 29); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline13); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 73, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'jedecP22Phosphors', transfer: 'smpte240m'} }); |
| try { |
| canvas4.getContext('webgl'); |
| } catch {} |
| let autogeneratedBindGroupLayout48 = pipeline13.getBindGroupLayout(0); |
| let textureView105 = texture98.createView({dimension: 'cube', mipLevelCount: 1}); |
| let textureView106 = texture44.createView({dimension: '2d'}); |
| let sampler70 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 94.39}); |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline11); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let sampler71 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest'}); |
| try { |
| renderPassEncoder34.setBindGroup(3, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup8, new Uint32Array(6624), 2_874, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(6, buffer32, 0, 287); |
| } catch {} |
| try { |
| renderPassEncoder26.insertDebugMarker('\u{1fbd3}'); |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte170m', transfer: 'bt709'} }); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 78, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 88, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 155, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 218, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let bindGroup55 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout27, |
| entries: [ |
| {binding: 78, resource: {buffer: buffer91, offset: 3072, size: 1108}}, |
| {binding: 155, resource: {buffer: buffer47, offset: 768, size: 15293}}, |
| {binding: 218, resource: textureView27}, |
| ], |
| }); |
| let querySet11 = device0.createQuerySet({type: 'occlusion', count: 1479}); |
| let textureView107 = texture9.createView({dimension: '3d'}); |
| try { |
| computePassEncoder24.setBindGroup(3, bindGroup45, new Uint32Array(7098), 1_422, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout49 = pipeline7.getBindGroupLayout(0); |
| let bindGroup56 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 4, resource: textureView81}, |
| {binding: 269, resource: {buffer: buffer8, offset: 2816, size: 736}}, |
| ], |
| }); |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let computePassEncoder81 = commandEncoder115.beginComputePass({label: '69'}); |
| let sampler72 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'linear', compare: 'greater-equal'}); |
| try { |
| computePassEncoder81.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup10, new Uint32Array(121), 0, 0); |
| } catch {} |
| await gc(); |
| try { |
| externalTexture4.label = '\u6686\u{1fb4e}\u49dd\ucfff\ue31c\u9c6a'; |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 78, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 88, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 155, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 218, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout50 = pipeline0.getBindGroupLayout(1); |
| let bindGroup57 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 378, resource: {buffer: buffer2, offset: 512, size: 600}}], |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let textureView108 = texture101.createView({aspect: 'depth-only', arrayLayerCount: 1}); |
| let computePassEncoder82 = commandEncoder116.beginComputePass({label: '70'}); |
| try { |
| computePassEncoder82.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 572, new DataView(new ArrayBuffer(16246)), 6802, 4108); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout37, |
| entries: [ |
| {binding: 155, resource: {buffer: buffer2, offset: 0}}, |
| {binding: 218, resource: textureView27}, |
| {binding: 78, resource: {buffer: buffer41, offset: 2304}}, |
| ], |
| }); |
| let commandEncoder117 = device0.createCommandEncoder(); |
| let texture105 = device0.createTexture({ |
| size: [8, 8, 22], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture106 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| computePassEncoder61.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup57, new Uint32Array(1243), 230, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer37, 'uint16', 178, 99); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder117.resolveQuerySet(querySet11, 211, 22, buffer67, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 19, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 23, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| {binding: 94, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 97, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 137, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout51 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder118 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer14, 'uint16', 240, 146); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| commandEncoder118.copyBufferToTexture({ |
| /* bytesInLastRow: 242 widthInBlocks: 242 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 6725 */ |
| offset: 6725, |
| bytesPerRow: 26624, |
| buffer: buffer2, |
| }, { |
| texture: texture86, |
| mipLevel: 0, |
| origin: {x: 30, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 242, height: 61, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 1352, new Float32Array(4379), 328, 32); |
| } catch {} |
| let pipeline16 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {1_579: 0}, |
| targets: [{format: 'r8sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| constants: {override3: 0, override5: 0, override4: 0}, |
| buffers: [ |
| { |
| arrayStride: 588, |
| attributes: [ |
| {format: 'unorm16x2', offset: 40, shaderLocation: 12}, |
| {format: 'unorm8x4', offset: 72, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', unclippedDepth: true}, |
| }); |
| let textureView109 = texture73.createView({mipLevelCount: 1, baseArrayLayer: 9, arrayLayerCount: 1}); |
| let computePassEncoder83 = commandEncoder118.beginComputePass({label: '71'}); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup34, []); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup30, new Uint32Array(3381), 238, 0); |
| } catch {} |
| try { |
| commandEncoder117.copyBufferToBuffer(buffer38, 2504, buffer13, 5804, 244); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 99, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 101, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData20 = new ImageData(4, 16); |
| let autogeneratedBindGroupLayout52 = pipeline5.getBindGroupLayout(1); |
| let bindGroup59 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout34, |
| entries: [{binding: 176, resource: {buffer: buffer46, offset: 3072, size: 5204}}], |
| }); |
| let texture107 = device0.createTexture({ |
| size: [8, 8, 22], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView110 = texture33.createView({format: 'rgba8unorm', baseArrayLayer: 0}); |
| let computePassEncoder84 = commandEncoder117.beginComputePass({label: '72'}); |
| try { |
| computePassEncoder84.setPipeline(pipeline0); |
| } catch {} |
| let autogeneratedBindGroupLayout53 = pipeline6.getBindGroupLayout(0); |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let querySet12 = device0.createQuerySet({type: 'occlusion', count: 566}); |
| let textureView111 = texture47.createView({dimension: '2d', format: 'r8sint', mipLevelCount: 1, baseArrayLayer: 1}); |
| let computePassEncoder85 = commandEncoder119.beginComputePass({label: '73'}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| computePassEncoder85.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup55); |
| } catch {} |
| let textureView112 = texture11.createView({baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 5}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: [], depthStencilFormat: 'depth32float', stencilReadOnly: false}); |
| try { |
| renderPassEncoder27.setBlendConstant({ r: -901.0, g: -544.2, b: 415.8, a: 556.4, }); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(2, buffer85, 0, 1_564); |
| } catch {} |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let textureView113 = texture6.createView({}); |
| let renderBundle11 = renderBundleEncoder11.finish({}); |
| try { |
| computePassEncoder77.setBindGroup(1, bindGroup50, new Uint32Array(4494), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer32); |
| } catch {} |
| try { |
| commandEncoder120.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 8}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer92 = device0.createBuffer({ |
| size: 11490, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let textureView114 = texture105.createView({arrayLayerCount: 3}); |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup59, []); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup51, new Uint32Array(1186), 274, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(4, undefined, 0, 33_496_071); |
| } catch {} |
| let texture108 = device0.createTexture({ |
| size: {width: 432, height: 120, depthOrArrayLayers: 2}, |
| mipLevelCount: 6, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView115 = texture3.createView({arrayLayerCount: 1}); |
| let computePassEncoder86 = commandEncoder120.beginComputePass({label: '74'}); |
| try { |
| computePassEncoder86.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup52, new Uint32Array(688), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline16); |
| } catch {} |
| let autogeneratedBindGroupLayout54 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| let renderPassEncoder35 = commandEncoder121.beginRenderPass({ |
| colorAttachments: [{view: textureView41, depthSlice: 123, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 310635653, |
| }); |
| try { |
| computePassEncoder69.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup15, new Uint32Array(619), 101, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBlendConstant({ r: -392.4, g: 671.4, b: 292.5, a: 553.6, }); |
| } catch {} |
| let imageData21 = new ImageData(56, 4); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup38, new Uint32Array(632), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup20, new Uint32Array(209), 56, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer5, 'uint32', 280, 258); |
| } catch {} |
| try { |
| adapter0.label = '\uf7e2\u{1fe8b}\udc7b\u{1fd4f}\u0b51\u08e6\u{1f8da}'; |
| } catch {} |
| let texture109 = device0.createTexture({ |
| size: [216, 60, 2], |
| mipLevelCount: 3, |
| format: 'astc-12x10-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder87 = commandEncoder122.beginComputePass({label: '75'}); |
| try { |
| computePassEncoder87.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup2, new Uint32Array(538), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 150, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData19, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 44, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let buffer93 = device0.createBuffer({ |
| size: 11817, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder123 = device0.createCommandEncoder(); |
| let computePassEncoder88 = commandEncoder123.beginComputePass({label: '76'}); |
| try { |
| computePassEncoder88.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(370); |
| } catch {} |
| try { |
| renderPassEncoder27.setViewport(52.11128918859228, 12.212237657923351, 35.91668841490431, 5.299611903645637, 0.971727050579545, 0.9829499641997317); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline16); |
| } catch {} |
| let pipeline17 = await device0.createComputePipelineAsync({layout: pipelineLayout5, compute: {module: shaderModule5}}); |
| let pipeline18 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule6, |
| constants: {11_640: 0}, |
| targets: [{ |
| format: 'r8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex1', |
| constants: {30_730: 0}, |
| buffers: [ |
| { |
| arrayStride: 572, |
| attributes: [ |
| {format: 'sint32x4', offset: 24, shaderLocation: 13}, |
| {format: 'sint16x4', offset: 84, shaderLocation: 2}, |
| ], |
| }, |
| {arrayStride: 544, attributes: [{format: 'snorm8x2', offset: 20, shaderLocation: 6}]}, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let buffer94 = device0.createBuffer({ |
| size: 17630, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder60.setBindGroup(3, bindGroup52, new Uint32Array(251), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup40, new Uint32Array(1560), 353, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer74, 'uint16', 4_368, 1_040); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline13); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let texture110 = device0.createTexture({ |
| size: {width: 54, height: 15, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup56, new Uint32Array(1962), 257, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer39, 0, 1_447); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| document.body.prepend(img2); |
| let commandEncoder124 = device0.createCommandEncoder(); |
| let querySet13 = device0.createQuerySet({type: 'occlusion', count: 165}); |
| let textureView116 = texture85.createView({aspect: 'stencil-only', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder25.setViewport(156.22733329194736, 58.18791727493248, 12.74931798933816, 0.9978337798319644, 0.30348329921584494, 0.5866854012985594); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer34.unmap(); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 303 */ |
| offset: 303, |
| bytesPerRow: 6656, |
| rowsPerImage: 145, |
| buffer: buffer0, |
| }, { |
| texture: texture73, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let renderPassEncoder36 = commandEncoder124.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView106, |
| clearValue: { r: -134.3, g: -506.7, b: -171.9, a: -459.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| |
| |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| videoFrame31.close(); |
| videoFrame32.close(); |
| videoFrame33.close(); |
| videoFrame34.close(); |
| videoFrame35.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> |
| |
