| <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?.waitUntilDone(); |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| 'float16-renderable', |
| 'float32-renderable', |
| 'core-features-and-limits', |
| 'timestamp-query', |
| ], |
| requiredLimits: {maxStorageBufferBindingSize: 136894040, maxUniformBufferBindingSize: 116605391}, |
| }); |
| let buffer0 = device0.createBuffer({size: 12, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| await gc(); |
| let buffer1 = device0.createBuffer({size: 112, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let texture0 = device0.createTexture({ |
| size: [180, 48, 1], |
| mipLevelCount: 2, |
| format: 'astc-10x8-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView0 = texture0.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass(); |
| let buffer2 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 133, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let textureView1 = texture0.createView({mipLevelCount: 1}); |
| let commandEncoder2 = device0.createCommandEncoder(); |
| let texture1 = device0.createTexture({ |
| size: {width: 180}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder1 = commandEncoder1.beginComputePass(); |
| let buffer3 = device0.createBuffer({ |
| size: 96, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 92.29, |
| compare: 'never', |
| }); |
| let sampler1 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 80.78, |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 1, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(255).fill(50), /* required buffer size: 255 */ |
| {offset: 255, rowsPerImage: 30}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout1 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0], |
| }); |
| let texture2 = device0.createTexture({ |
| size: [64, 64, 88], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture3 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| commandEncoder2.clearBuffer(buffer3); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture4 = device0.createTexture({ |
| size: {width: 22}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView2 = texture3.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture5 = device0.createTexture({ |
| size: {width: 7}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture6 = device0.createTexture({ |
| size: {width: 7}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| let offscreenCanvas0 = new OffscreenCanvas(103, 112); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| label: '\u39f9\u{1f827}', |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 56, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 591, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let texture7 = device0.createTexture({ |
| size: [1, 540, 93], |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture8 = device0.createTexture({size: [7], dimension: '1d', format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST}); |
| let textureView3 = texture8.createView({}); |
| let computePassEncoder2 = commandEncoder2.beginComputePass(); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 1); |
| } catch {} |
| try { |
| globalThis.someLabel = commandEncoder2.label; |
| } catch {} |
| let texture9 = device0.createTexture({ |
| size: [90], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let imageData0 = new ImageData(40, 172); |
| let texture10 = device0.createTexture({ |
| size: [1, 540, 32], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture11 = device0.createTexture({ |
| size: [1, 1080, 20], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let offscreenCanvas1 = new OffscreenCanvas(162, 31); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 56, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 591, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView4 = texture5.createView({arrayLayerCount: 1}); |
| let textureView5 = texture10.createView({mipLevelCount: 1}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder1.setVertexBuffer(7, buffer3, 0, 4); |
| } catch {} |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| let texture12 = device0.createTexture({ |
| size: [150, 1, 186], |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let sampler2 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 53.44, compare: 'less-equal'}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer0, 'uint16', 2, 3); |
| } catch {} |
| try { |
| renderBundleEncoder0.insertDebugMarker('\ua20f'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer4 = device0.createBuffer({size: 92, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder6 = device0.createCommandEncoder(); |
| let texture13 = device0.createTexture({ |
| size: [15, 1, 29], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture14 = device0.createTexture({ |
| size: {width: 75, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| sampleCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder3 = commandEncoder3.beginComputePass(); |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let buffer5 = device0.createBuffer({size: 52, usage: GPUBufferUsage.UNIFORM}); |
| let textureView6 = texture12.createView({dimension: '2d', format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 53}); |
| try { |
| renderBundleEncoder1.setVertexBuffer(5, buffer4, 0, 11); |
| } catch {} |
| try { |
| commandEncoder5.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 2, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let texture15 = device0.createTexture({ |
| size: [30, 1, 11], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 0, new Uint32Array(1324).map((_, i) => i * 8), 272, 4); |
| } catch {} |
| let textureView7 = texture15.createView({}); |
| let computePassEncoder4 = commandEncoder6.beginComputePass(); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 2, 3); |
| } catch {} |
| try { |
| commandEncoder4.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 96 */ |
| offset: 96, |
| buffer: buffer1, |
| }, { |
| texture: texture10, |
| mipLevel: 2, |
| origin: {x: 0, y: 2, z: 1}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let textureView8 = texture7.createView({}); |
| let computePassEncoder5 = commandEncoder4.beginComputePass(); |
| try { |
| buffer4.unmap(); |
| } catch {} |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext0 = offscreenCanvas1.getContext('webgpu'); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 515, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 529, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 591, resource: textureView6}, |
| {binding: 8, resource: textureView7}, |
| {binding: 56, resource: textureView1}, |
| {binding: 1, resource: textureView4}, |
| ], |
| }); |
| let buffer6 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer4, 4, 24); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(344).fill(43), /* required buffer size: 344 */ |
| {offset: 344}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({ |
| size: {width: 30, height: 1, depthOrArrayLayers: 52}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| offscreenCanvas0.getContext('bitmaprenderer'); |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 1, resource: textureView4}, |
| {binding: 8, resource: textureView7}, |
| {binding: 591, resource: textureView6}, |
| {binding: 56, resource: textureView0}, |
| ], |
| }); |
| let pipelineLayout3 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout0], |
| }); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(3, buffer4, 0, 41); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12, new Float32Array(7943).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.8139)), 3534, 0); |
| } catch {} |
| let textureView9 = texture12.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 59}); |
| let computePassEncoder6 = commandEncoder5.beginComputePass(); |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 591, resource: textureView6}, |
| {binding: 56, resource: textureView0}, |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView4}, |
| ], |
| }); |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let imageData1 = new ImageData(24, 8); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let computePassEncoder7 = commandEncoder11.beginComputePass(); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let videoFrame0 = new VideoFrame(offscreenCanvas1, {timestamp: 0}); |
| let buffer7 = device0.createBuffer({size: 19852, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let sampler3 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.39, |
| maxAnisotropy: 7, |
| }); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer6, 'uint16', 0, 68); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let texture17 = device0.createTexture({ |
| size: {width: 7, height: 1, depthOrArrayLayers: 71}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup1, []); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1376 */ |
| offset: 1376, |
| bytesPerRow: 6400, |
| buffer: buffer7, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder0.insertDebugMarker('\u31d2'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 3_344, new Uint32Array(354).map((_, i) => i * 1), 31); |
| } catch {} |
| let buffer8 = device0.createBuffer({size: 28, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(302_102).fill(157), /* required buffer size: 302_102 */ |
| {offset: 214, bytesPerRow: 64, rowsPerImage: 53}, {width: 13, height: 0, depthOrArrayLayers: 90}); |
| } catch {} |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| try { |
| device0.queue.writeBuffer(buffer3, 36, new Uint32Array(29413).map((_, i) => i * 3), 163, 0); |
| } catch {} |
| let videoFrame1 = new VideoFrame(offscreenCanvas0, {timestamp: 0}); |
| let buffer9 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDIRECT}); |
| let textureView10 = texture6.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(355), 92, 0); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 56, resource: textureView1}, |
| {binding: 591, resource: textureView9}, |
| {binding: 1, resource: textureView10}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 11}); |
| let texture18 = device0.createTexture({ |
| size: {width: 30}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(71).fill(233), /* required buffer size: 71 */ |
| {offset: 71, bytesPerRow: 9}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 56, resource: textureView1}, |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView4}, |
| {binding: 591, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let textureView11 = texture0.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1420 */ |
| offset: 1420, |
| bytesPerRow: 67072, |
| buffer: buffer7, |
| }, { |
| texture: texture14, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder8 = commandEncoder16.beginComputePass(); |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let sampler4 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 36.78}); |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 128 */ |
| offset: 128, |
| bytesPerRow: 22272, |
| rowsPerImage: 190, |
| buffer: buffer7, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 28, new Uint32Array(3820).map((_, i) => i * 8), 364, 4); |
| } catch {} |
| try { |
| await promise1; |
| } catch {} |
| let buffer10 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST}); |
| let texture19 = device0.createTexture({ |
| size: [75, 1, 46], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer6, 'uint32', 8, 8); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1176 */ |
| offset: 1176, |
| rowsPerImage: 433, |
| buffer: buffer7, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 12, new Uint32Array(17252).map((_, i) => i * 7), 240, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 6, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 56, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 591, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let textureView12 = texture8.createView({}); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder5.setVertexBuffer(5, buffer4, 4, 0); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToBuffer(buffer7, 3920, buffer10, 16, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 14, y: 11 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let texture20 = device0.createTexture({ |
| size: {width: 37, height: 1, depthOrArrayLayers: 77}, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 784 */ |
| offset: 784, |
| bytesPerRow: 16128, |
| buffer: buffer7, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let texture21 = device0.createTexture({ |
| size: [1], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView13 = texture0.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup2, new Uint32Array(317), 9, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| device0.label = '\u0e88\u06ee\u72c5\u0aa2\u{1ffb7}\u7ec9\u0304\u8ee1\u08d5\u70d3'; |
| } catch {} |
| let buffer11 = device0.createBuffer({size: 68, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture22 = device0.createTexture({ |
| size: {width: 7, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView14 = texture6.createView({arrayLayerCount: 1}); |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer1, 24, buffer3, 4, 0); |
| } catch {} |
| let buffer12 = device0.createBuffer({size: 308, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture23 = device0.createTexture({ |
| size: [45, 12, 24], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup0, new Uint32Array(182), 24, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer11, 'uint32', 0, 8); |
| } catch {} |
| let texture24 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder9 = commandEncoder19.beginComputePass(); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(2632), 7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer11, 'uint16', 6, 5); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| try { |
| commandEncoder7.resolveQuerySet(querySet0, 1, 0, buffer3, 0); |
| } catch {} |
| let commandEncoder22 = device0.createCommandEncoder({label: '\uba2f\u7231'}); |
| let sampler5 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat'}); |
| let buffer13 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder5.setVertexBuffer(4, buffer4, 4, 48); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 1, |
| origin: {x: 0, y: 9, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 1, |
| origin: {x: 0, y: 9, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 52, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 56, resource: textureView1}, |
| {binding: 1, resource: textureView4}, |
| {binding: 591, resource: textureView6}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let commandBuffer0 = commandEncoder6.finish(); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']}); |
| let sampler6 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 62.54, |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup3, []); |
| } catch {} |
| let imageData2 = new ImageData(84, 24); |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let textureView15 = texture5.createView({}); |
| let computePassEncoder10 = commandEncoder14.beginComputePass(); |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 591, resource: textureView9}, |
| {binding: 1, resource: textureView15}, |
| {binding: 56, resource: textureView0}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let buffer14 = device0.createBuffer({size: 97, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 8, new Uint16Array(12010).map((_, i) => i + 2), 4020, 0); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 591, resource: textureView9}, |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView4}, |
| {binding: 56, resource: textureView0}, |
| ], |
| }); |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let textureView16 = texture9.createView({baseArrayLayer: 0}); |
| let texture25 = device0.createTexture({ |
| size: [60, 1, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView17 = texture19.createView({format: 'bgra8unorm', baseArrayLayer: 3, arrayLayerCount: 3}); |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer6, 'uint32', 16, 26); |
| } catch {} |
| let texture26 = device0.createTexture({ |
| size: {width: 30, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup2, new Uint32Array(383), 20, 0); |
| } catch {} |
| let computePassEncoder11 = commandEncoder26.beginComputePass(); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let texture27 = device0.createTexture({ |
| size: {width: 7}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup3); |
| } catch {} |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView14}, |
| {binding: 56, resource: textureView1}, |
| {binding: 591, resource: textureView9}, |
| ], |
| }); |
| let textureView18 = texture2.createView({}); |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 180 */ |
| offset: 180, |
| bytesPerRow: 4096, |
| rowsPerImage: 2218, |
| buffer: buffer7, |
| }, { |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 7_396, new DataView(new Uint8Array(5286).map((_, i) => i).buffer), 2490); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture28 = device0.createTexture({ |
| size: {width: 22, height: 6, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true}); |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer0, 'uint16', 10, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(7, buffer0, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 3104 */ |
| offset: 3104, |
| bytesPerRow: 2816, |
| buffer: buffer7, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 60, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder2.pushDebugGroup('\u231d'); |
| } catch {} |
| try { |
| adapter0.label = '\u0c61\u{1face}\u{1ffe7}\u166e\u133c'; |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: textureView15}, |
| {binding: 591, resource: textureView9}, |
| {binding: 56, resource: textureView1}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let querySet1 = device0.createQuerySet({type: 'timestamp', count: 1335}); |
| let textureView19 = texture26.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| commandEncoder15.resolveQuerySet(querySet1, 56, 7, buffer12, 0); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| struct ComputeInput1 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| struct T2 { |
| @align(32) @size(128) f0: atomic<u32>, |
| f1: array<array<atomic<u32>, 1>>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn1(a0: ptr<storage, T5, read>, a1: vec2i) { |
| { |
| while bool(firstLeadingBit(vec4i(unconst_i32(34016788), unconst_i32(577069947), unconst_i32(244126001), unconst_i32(45569931))).r) { |
| _ = fn0(); |
| } |
| } |
| _ = fn0(); |
| _ = fn0(); |
| let vf2: vec4f = (unconst_f32(0.1817) + vec4f( !vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false), unconst_bool(false)))); |
| } |
| |
| struct T0 { |
| f0: array<array<f16, 16>>, |
| } |
| |
| @group(0) @binding(133) var<storage, read> buffer15: array<T5>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(1) @binding(133) var<storage, read> buffer16: array<T5>; |
| |
| struct T4 { |
| f0: array<vec4h>, |
| } |
| |
| struct ComputeInput0 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| /* zero global variables used */ |
| fn fn0() -> array<array<bool, 51>, 1> { |
| var out: array<array<bool, 51>, 1>; |
| let vf0: i32 = dot4I8Packed(unconst_u32(196447646), unconst_u32(445309581)); |
| let vf1: i32 = dot4I8Packed(unconst_u32(1050131485), unconst_u32(731961562)); |
| out[0][unconst_u32(87195638)] = any((vec2u(unconst_u32(912779347), unconst_u32(169099320)) <= vec2u(unconst_u32(1826154156), unconst_u32(612086114)))); |
| return out; |
| } |
| |
| struct ComputeInput2 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct T1 { |
| @size(284) f0: i32, |
| } |
| |
| struct T6 { |
| f0: array<u32>, |
| } |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| /* zero global variables used */ |
| fn fn2() -> array<vec4i, 1> { |
| var out: array<vec4i, 1>; |
| let ptr0: ptr<function, vec4i> = &out[unconst_u32(657473555)]; |
| let ptr1: ptr<function, vec4i> = &(*ptr0); |
| out[unconst_u32(77946428)] |= vec4i((*ptr0)[unconst_u32(479308261)]); |
| let ptr2: ptr<function, vec4i> = &out[unconst_u32(649317648)]; |
| out[unconst_u32(886122905)] ^= out[unconst_u32(70805560)]; |
| for (var jj53=0u; jj53<3; jj53++) { out[jj53] = vec4i(out[unconst_u32(775208416)][unconst_u32(352445595)]); } |
| return out; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn4() -> f16 { |
| var out: f16; |
| var vf4: vec2u = (vec2u(unconst_u32(982949025), unconst_u32(208673024)) & vec2u(unconst_u32(83221403), unconst_u32(3390752))); |
| out *= f16(any((vec4f(unconst_f32(0.00669), unconst_f32(0.02837), unconst_f32(0.08102e25), unconst_f32(0.3797e-37)) >= unpack4x8snorm(vf4[unconst_u32(59026669)])))); |
| let vf5: f32 = step(unconst_f32(0.00466), f32(max(bitcast<i32>(abs(vec2u(pack4xI8Clamp(vec4i(unconst_i32(622246296), unconst_i32(12510308), unconst_i32(456551234), unconst_i32(-112237481)))))[0]), unconst_i32(1477324145)))); |
| out -= sqrt(vec4h(f16(vf5)))[1]; |
| out = f16(dot(vec3f(f32(pack2x16snorm(vec2f(unconst_f32(0.1570e2), unconst_f32(0.9080e-7))))), vec3f(unconst_f32(0.00574e35), unconst_f32(0.01726e12), unconst_f32(0.2957)))); |
| while bool(radians(unconst_f16(1952.1))) { |
| out = out; |
| loop { |
| out = vec2h(log(vec2f(unconst_f32(0.06368), unconst_f32(0.2951e37))).yx.rr)[0]; |
| switch pack2x16snorm(vec2f(unconst_f32(-0.5844), unconst_f32(0.09343e-17))) { |
| default { |
| out += vec4h(sinh(vec4f(unconst_f32(0.06915), unconst_f32(0.01259), unconst_f32(0.03417e8), unconst_f32(0.08707e-44)))).a; |
| break; |
| } |
| } |
| var vf6: mat4x2f = transpose(mat2x4f(unconst_f32(0.1014), unconst_f32(0.4114), unconst_f32(0.1347), unconst_f32(0.1083e2), unconst_f32(0.01160), unconst_f32(0.07044e8), unconst_f32(-0.3831e0), unconst_f32(0.1414))); |
| break; |
| } |
| out = sin(vec4h(unconst_f16(2413.0), unconst_f16(6817.8), unconst_f16(8196.3), unconst_f16(4681.4))).x; |
| var vf7: vec3u = countOneBits(vec3u(unconst_u32(6691913), unconst_u32(20850293), unconst_u32(216786730))); |
| let ptr4: ptr<function, vec3u> = &vf7; |
| return out; |
| } |
| let vf8: vec3h = tan(vec3h(f16(vf4[unconst_u32(227400722)]))); |
| out = f16(sqrt(bitcast<vec3f>(abs(vec2u(unconst_u32(505423340), unconst_u32(404792524))).rgg))[1]); |
| return out; |
| } |
| |
| struct T5 { |
| @size(896) f0: T1, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: buffer15, buffer16 */ |
| fn fn3(a0: vec4u, a1: ptr<function, array<bool, 1>>) -> vec2<bool> { |
| var out: vec2<bool>; |
| let ptr3: ptr<storage, T1, read> = &(*&buffer16)[arrayLength(&(*&buffer16))].f0; |
| (*a1)[u32((*&buffer16)[unconst_i32(152813087)].f0.f0)] = bool((*&buffer15)[arrayLength(&(*&buffer15))].f0.f0); |
| for (var jj71=0u; jj71<3; jj71++) { (*a1)[jj71] = bool(radians(vec4h(unconst_f16(4424.5), unconst_f16(18489.9), unconst_f16(29977.8), unconst_f16(-403.3)))[0]); } |
| out = vec2<bool>((unconst_f16(2527.6) < unconst_f16(27087.2))); |
| fn0(); |
| _ = fn0(); |
| let vf3: u32 = arrayLength(&(*&buffer16)); |
| return out; |
| _ = buffer15; |
| _ = buffer16; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| /* used global variables: buffer15, buffer16 */ |
| @compute @workgroup_size(1, 2, 2) |
| fn compute0(a0: ComputeInput0, a1: ComputeInput1, a2: ComputeInput2) { |
| loop { |
| break; |
| } |
| let ptr5: ptr<storage, T5, read> = &(*&buffer15)[unconst_i32(1174891375)]; |
| let vf9: u32 = a0.num_workgroups[unconst_u32(196450928)]; |
| fn0(); |
| fn1(&(*ptr5), vec2i(i32(arrayLength(&(*&buffer15))))); |
| let ptr6: ptr<storage, T1, read> = &buffer16[unconst_u32(132048515)].f0; |
| _ = buffer15; |
| _ = buffer16; |
| }`, |
| }); |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 56, resource: textureView1}, |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView10}, |
| {binding: 591, resource: textureView9}, |
| ], |
| }); |
| let buffer17 = device0.createBuffer({size: 48, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let texture29 = device0.createTexture({ |
| size: {width: 180, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup6, new Uint32Array(260), 89, 0); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let buffer18 = device0.createBuffer({size: 184, usage: GPUBufferUsage.INDEX}); |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup7, new Uint32Array(257), 21, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 515, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 529, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer19 = device0.createBuffer({size: 253, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm']}); |
| try { |
| commandEncoder8.resolveQuerySet(querySet0, 0, 1, buffer12, 0); |
| } catch {} |
| try { |
| commandEncoder24.pushDebugGroup('\uaece'); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1, stencilReadOnly: true}); |
| let sampler7 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 76.22, |
| }); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup3); |
| } catch {} |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup3, new Uint32Array(213), 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer0, 'uint32', 0, 1); |
| } catch {} |
| try { |
| commandEncoder8.copyBufferToBuffer(buffer7, 1216, buffer10, 32, 0); |
| } catch {} |
| try { |
| commandEncoder29.copyTextureToTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture30 = device0.createTexture({ |
| size: [75, 1, 97], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder12 = commandEncoder17.beginComputePass(); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true}); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder24.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 25, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let textureView20 = texture26.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], stencilReadOnly: true}); |
| try { |
| device0.queue.writeBuffer(buffer7, 492, new BigInt64Array(4229).map((_, i) => BigInt(i - 2)), 571, 60); |
| } catch {} |
| let buffer20 = device0.createBuffer({ |
| size: 12, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder31 = device0.createCommandEncoder(); |
| let textureView21 = texture9.createView({dimension: '1d', arrayLayerCount: 1}); |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| commandEncoder27.insertDebugMarker('\ub9ea'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 4_944, new Uint32Array(1177).map((_, i) => i * 6), 724, 96); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 28, y: 88 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer21 = device0.createBuffer({size: 240, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let computePassEncoder13 = commandEncoder33.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup9, new Uint32Array(1609), 364, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(1, buffer0, 0); |
| } catch {} |
| try { |
| await promise0; |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 56, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 591, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer22 = device0.createBuffer({size: 636, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let computePassEncoder14 = commandEncoder12.beginComputePass(); |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup2, new Uint32Array(1351), 627, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer19, 'uint32', 20, 10); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(6, buffer4, 0, 61); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder9.insertDebugMarker('\u1a98'); |
| } catch {} |
| offscreenCanvas1.height = 1879; |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| buffer1.label = '\u4965\uc687\uee7a\ua269\uaf67\u34d0\udfdb'; |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| /* zero global variables used */ |
| fn fn0() -> array<f16, 1> { |
| var out: array<f16, 1>; |
| var vf10: vec2i = ~vec2i(unconst_i32(197945534), unconst_i32(218678378)); |
| var vf11: bool = (unconst_bool(true) && bool(acos(vec4h(unconst_f16(15366.6), unconst_f16(-25035.2), unconst_f16(5093.8), unconst_f16(-7193.6))).a)); |
| var vf12: vec4i = countLeadingZeros(vec4i(override0)); |
| vf10 = ~vec2i(unconst_i32(245053450), unconst_i32(156707465)); |
| var vf13: vec3u = insertBits(vec3u(unconst_u32(889426444), unconst_u32(314181678), unconst_u32(1025409309)), vec3u(unconst_u32(335749758), unconst_u32(687285569), unconst_u32(305598023)), unconst_u32(705565848), unconst_u32(50723863)); |
| out[unconst_u32(719021579)] -= f16(vf11); |
| switch bitcast<u32>(log(vec2h(unconst_f16(2988.8), unconst_f16(5866.3)))) { |
| default: { |
| var vf14: f16 = length(vec3h(normalize(vec3f(unconst_f32(0.00526e1), unconst_f32(0.02391), unconst_f32(0.06068))).xzy.zyz.ggg.grb)); |
| vf14 = out[0]; |
| loop { |
| out[unconst_u32(647728562)] += f16( !unconst_bool(false)); |
| break; |
| } |
| out[unconst_u32(653580881)] += f16(atan2(unconst_f32(0.1642e31), unconst_f32(0.03440))); |
| var vf15: f32 = atan2(vec4f(unpack4xU8(unconst_u32(1803103119)).bgaa).r, unconst_f32(0.01752e13)); |
| vf14 = smoothstep(unconst_f16(5440.5), unconst_f16(7170.1), out[unconst_u32(210192196)]); |
| break; |
| } |
| } |
| vf13 = vec3u(u32(vf11)); |
| return out; |
| _ = override0; |
| } |
| |
| struct ComputeInput5 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| struct ComputeInput4 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct VertexInput2 { |
| @location(12) @interpolate(flat) location_12: u32, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput6 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct ComputeInput3 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| struct VertexInput0 { |
| @location(10) location_10: vec4f, |
| @location(5) location_5: i32, |
| } |
| |
| struct T0 { |
| @size(128) f0: atomic<i32>, |
| f1: array<array<array<array<atomic<i32>, 8>, 1>, 1>>, |
| } |
| |
| struct VertexInput4 { |
| @location(3) location_3: f16, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T2 { |
| f0: array<array<vec2h, 1>, 1>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexInput5 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct VertexOutput0 { |
| @location(6) location_6: vec4f, |
| @location(0) @interpolate(flat, first) location_0: vec4u, |
| @location(11) @interpolate(flat, either) location_11: u32, |
| @location(5) location_5: vec4i, |
| @location(10) @interpolate(perspective, centroid) location_10: vec4h, |
| @location(12) location_12: vec2u, |
| @location(2) location_2: vec2i, |
| @location(9) @interpolate(perspective, either) location_9: vec4h, |
| @location(1) location_1: u32, |
| @builtin(position) position: vec4f, |
| @location(3) @interpolate(perspective) location_3: vec2f, |
| @location(15) location_15: vec4u, |
| @location(7) location_7: vec4f, |
| @location(14) @interpolate(flat, centroid) location_14: f16, |
| @location(4) location_4: vec2f, |
| @location(8) location_8: vec4u, |
| @location(13) @interpolate(flat, first) location_13: vec4u, |
| } |
| |
| @id(28210) override override0: i32; |
| |
| struct VertexInput1 { |
| @location(7) location_7: vec4i, |
| @location(6) location_6: vec4f, |
| @location(14) @interpolate(flat, center) location_14: vec2u, |
| @location(11) location_11: f16, |
| @location(0) @interpolate(flat) location_0: vec4h, |
| @location(8) @interpolate(linear) location_8: vec2f, |
| @location(9) location_9: vec2h, |
| @location(1) location_1: i32, |
| @location(15) location_15: vec2i, |
| @location(13) location_13: vec4h, |
| } |
| |
| struct T1 { |
| f0: array<atomic<u32>>, |
| } |
| |
| /* zero global variables used */ |
| fn fn1(a0: array<array<i32, 26>, 1>) { |
| var vf16 = fn0(); |
| var vf17 = fn0(); |
| var vf18 = fn0(); |
| loop { |
| var vf19 = fn0(); |
| vf19[unconst_u32(632297094)] = f16(pack4x8unorm(vec4f(unconst_f32(-0.3162), unconst_f32(0.1430), unconst_f32(0.1114e31), unconst_f32(0.00271)))); |
| vf19[pack4xI8(vec4i(bitcast<i32>(pack4x8unorm(vec4f(unconst_f32(0.1078), unconst_f32(0.01208e0), unconst_f32(0.1182), unconst_f32(-0.6244))))))] = (vec3h(log(vec2f(unconst_f32(0.01384e29), unconst_f32(0.3434))).ggr) * mat2x3h(unconst_f16(1593.5), unconst_f16(19077.9), unconst_f16(8116.6), unconst_f16(33835.8), unconst_f16(16494.7), unconst_f16(14345.4))).x; |
| break; |
| _ = override0; |
| } |
| var vf20 = fn0(); |
| vf17[0] += f16((unconst_bool(true) && unconst_bool(true))); |
| vf17[unconst_u32(1204724426)] = vec3h((vec3i(unconst_i32(70952028), unconst_i32(1608299972), unconst_i32(34711808)) > vec3i(unconst_i32(391338829), unconst_i32(359643932), unconst_i32(10420660)))).r; |
| vf18[unconst_u32(621180388)] *= vf17[0]; |
| let vf21: vec4i = unpack4xI8(unconst_u32(691008751)); |
| let vf22: i32 = a0[unconst_u32(78829425)][25]; |
| fn0(); |
| _ = override0; |
| } |
| |
| struct VertexInput3 { |
| @location(4) location_4: u32, |
| } |
| |
| @group(0) @binding(133) var<storage, read> buffer23: array<array<array<array<ComputeInput3, 7>, 1>, 32>>; |
| |
| @group(1) @binding(133) var<storage, read> buffer24: array<array<array<f16, 1>, 448>>; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex0(a0: VertexInput0, @location(2) location_2: vec2h, a2: VertexInput1, a3: VertexInput2, a4: VertexInput3, a5: VertexInput4, a6: VertexInput5, a7: VertexInput6) -> VertexOutput0 { |
| var out: VertexOutput0; |
| var vf23: u32 = a6.vertex_index; |
| return out; |
| } |
| |
| /* used global variables: buffer23, buffer24 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute1(a0: ComputeInput3, @builtin(global_invocation_id) global_invocation_id: vec3u) { |
| let ptr7: ptr<storage, u32, read> = &(*&buffer23)[unconst_u32(15226810)][unconst_u32(553570849)][unconst_u32(5093040)][6].local_invocation_index; |
| while bool(buffer23[unconst_u32(1951713526)][31][0][6].local_invocation_index) { |
| let ptr8: ptr<storage, f16, read> = &buffer24[unconst_u32(52347364)][447][unconst_u32(264694891)]; |
| _ = buffer24; |
| } |
| _ = fn0(); |
| let ptr9: ptr<storage, u32, read> = &buffer23[(*&buffer23)[unconst_u32(335320735)][unconst_u32(1111373630)][0][6].local_invocation_index][31][unconst_u32(362605041)][6].local_invocation_index; |
| if bool((*&buffer23)[arrayLength(&(*&buffer23))][31][0][unconst_u32(257232202)].local_invocation_index) { |
| if bool(cosh(vec2h(unconst_f16(1504.5), unconst_f16(5100.3)))[1]) { |
| _ = fn0(); |
| _ = override0; |
| } |
| _ = override0; |
| } |
| let ptr10: ptr<storage, f16, read> = &buffer24[unconst_u32(260969196)][447][(*&buffer23)[unconst_u32(177687776)][unconst_u32(1134269848)][unconst_u32(203032228)][6].local_invocation_index]; |
| _ = override0; |
| _ = buffer24; |
| _ = buffer23; |
| } |
| |
| /* used global variables: buffer24 */ |
| @compute @workgroup_size(1, 2, 1) |
| fn compute2(a0: ComputeInput4, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, a4: ComputeInput5) { |
| let ptr11: ptr<storage, array<f16, 1>, read> = &(*&buffer24)[u32((*&buffer24)[arrayLength(&(*&buffer24))][447][0])][unconst_u32(502479875)]; |
| let vf24: f16 = smoothstep(unconst_f16(22848.4), unconst_f16(105.0), unconst_f16(7881.6)); |
| let ptr12: ptr<storage, array<array<array<f16, 1>, 448>>, read> = &(*&buffer24); |
| _ = buffer24; |
| }`, |
| }); |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 1, resource: textureView4}, |
| {binding: 56, resource: textureView1}, |
| {binding: 8, resource: textureView7}, |
| {binding: 591, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 515, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 529, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer25 = device0.createBuffer({size: 260, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let texture31 = device0.createTexture({ |
| size: {width: 150, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(812), 238, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer11, 'uint16', 2, 2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer3); |
| } catch {} |
| let texture32 = device0.createTexture({ |
| size: {width: 30}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup8, []); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(4, buffer12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 16, new DataView(new Uint8Array(3242).map((_, i) => i).buffer), 1917, 0); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let texture33 = device0.createTexture({size: [1], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView22 = texture5.createView({}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 0, 3); |
| } catch {} |
| try { |
| commandEncoder13.pushDebugGroup('\u07ce'); |
| } catch {} |
| try { |
| renderBundleEncoder13.insertDebugMarker('\ud92a'); |
| } catch {} |
| let commandEncoder37 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup3, new Uint32Array(4679), 24, 0); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 8, resource: textureView18}, |
| {binding: 1, resource: textureView4}, |
| {binding: 591, resource: textureView6}, |
| {binding: 56, resource: textureView0}, |
| ], |
| }); |
| let buffer26 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup0, new Uint32Array(452), 342, 0); |
| } catch {} |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup4, new Uint32Array(53), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup0, new Uint32Array(2615), 18, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer18, 'uint16', 20, 55); |
| } catch {} |
| await gc(); |
| let texture34 = device0.createTexture({ |
| size: {width: 90}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| commandEncoder30.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4448 */ |
| offset: 4448, |
| bytesPerRow: 3328, |
| buffer: buffer7, |
| }, { |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder9.resolveQuerySet(querySet1, 1218, 3, buffer22, 256); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let texture35 = device0.createTexture({ |
| size: [1], |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer19, 'uint32', 216, 2); |
| } catch {} |
| try { |
| renderBundleEncoder2.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder38 = device0.createCommandEncoder(); |
| let textureView23 = texture0.createView({format: 'astc-10x8-unorm', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder6.setVertexBuffer(3, buffer7, 3_684, 580); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 8, new Uint32Array(10848).map((_, i) => i * 5), 1312, 0); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 1, resource: textureView15}, |
| {binding: 8, resource: textureView7}, |
| {binding: 56, resource: textureView23}, |
| {binding: 591, resource: textureView6}, |
| ], |
| }); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer27 = device0.createBuffer({size: 252, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let sampler8 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer0, 'uint16', 4, 0); |
| } catch {} |
| let pipeline0 = device0.createComputePipeline({ |
| layout: pipelineLayout1, |
| compute: {module: shaderModule1, entryPoint: 'compute1', constants: {28_210: 1}}, |
| }); |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 133, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder39 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView16}, |
| {binding: 591, resource: textureView9}, |
| {binding: 56, resource: textureView23}, |
| ], |
| }); |
| let buffer28 = device0.createBuffer({size: 199, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder40 = device0.createCommandEncoder(); |
| try { |
| renderBundleEncoder14.setVertexBuffer(6, buffer20); |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView24 = texture18.createView({}); |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| let buffer29 = device0.createBuffer({ |
| size: 136, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder42 = device0.createCommandEncoder(); |
| let textureView25 = texture12.createView({mipLevelCount: 1, baseArrayLayer: 24, arrayLayerCount: 8}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 20, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let textureView26 = texture12.createView({format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 22, arrayLayerCount: 2}); |
| try { |
| commandEncoder13.popDebugGroup(); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer20, 'uint16', 2, 3); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(2, buffer0, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(8_578).fill(1), /* required buffer size: 8_578 */ |
| {offset: 82, bytesPerRow: 72, rowsPerImage: 59}, {width: 2, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| let promise5 = device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup12, []); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup9, new Uint32Array(1401), 25, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer6, 'uint16', 86, 1); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 264 */ |
| offset: 264, |
| rowsPerImage: 236, |
| buffer: buffer7, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte170m', transfer: 'iec61966-2-1'} }); |
| let buffer30 = device0.createBuffer({size: 36, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let commandEncoder43 = device0.createCommandEncoder(); |
| let textureView27 = texture32.createView({}); |
| let texture36 = device0.createTexture({ |
| size: [7, 1, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 8, new Float32Array(878).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.1452)), 87, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 1, y: 24 }, |
| flipY: false, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture37 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView28 = texture14.createView({format: 'bgra8unorm', mipLevelCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup6, new Uint32Array(498), 36, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 4, new Uint32Array(3358).map((_, i) => i * 8), 103, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer20, 0, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 133, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer31 = device0.createBuffer({ |
| label: '\u0398\u{1fd49}\u0692\u5a01\u9535\u00c3\u5d15\u0a79\u19b3', |
| size: 48, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: {width: 30, height: 1, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(1, buffer27, 4, 7); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 8, new Float64Array(15316).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/15312)), 1493, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture39 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 264}, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup12, new Uint32Array(293), 62, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer0, 'uint16', 0, 1); |
| } catch {} |
| let textureView29 = texture1.createView({format: 'rgba16sint'}); |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder34.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 524 */ |
| offset: 524, |
| bytesPerRow: 2304, |
| buffer: buffer7, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 0, y: 32, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 73, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder10.clearBuffer(buffer29, 20); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 4, new Uint32Array(14273).map((_, i) => i * 4), 1897, 0); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 8, resource: textureView7}, |
| {binding: 591, resource: textureView6}, |
| {binding: 56, resource: textureView1}, |
| {binding: 1, resource: textureView22}, |
| ], |
| }); |
| let buffer32 = device0.createBuffer({size: 8812, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let texture40 = device0.createTexture({ |
| size: {width: 45, height: 12, depthOrArrayLayers: 115}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer27, 0, 7); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new DataView(new Uint8Array(1488).map((_, i) => i).buffer), 695, 24); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(1); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let texture41 = device0.createTexture({ |
| size: {width: 90, height: 24, depthOrArrayLayers: 1}, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView30 = texture29.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup11, new Uint32Array(1366), 439, 0); |
| } catch {} |
| let buffer33 = device0.createBuffer({size: 12436, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView31 = texture16.createView({dimension: '2d', baseArrayLayer: 22}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup1, new Uint32Array(166), 61, 0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer19, 'uint32', 36, 3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(21).fill(6), /* required buffer size: 21 */ |
| {offset: 21}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer34 = device0.createBuffer({size: 6, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let renderPassEncoder0 = commandEncoder23.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: -407.9, g: 630.9, b: -758.3, a: -189.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder47 = device0.createCommandEncoder(); |
| let textureView32 = texture34.createView({}); |
| let computePassEncoder15 = commandEncoder10.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 535}}); |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer4); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer6, 'uint32', 4, 8); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(3, buffer12, 0); |
| } catch {} |
| try { |
| commandEncoder36.clearBuffer(buffer29); |
| } catch {} |
| try { |
| commandEncoder36.resolveQuerySet(querySet0, 1, 0, buffer26, 0); |
| } catch {} |
| try { |
| computePassEncoder12.insertDebugMarker('\u3c94'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 6_256, new Uint32Array(535).map((_, i) => i * 5)); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let textureView33 = texture14.createView({dimension: '2d', mipLevelCount: 2}); |
| let computePassEncoder16 = commandEncoder32.beginComputePass(); |
| let renderPassEncoder1 = commandEncoder45.beginRenderPass({ |
| label: '\u00de\u5185\u9a37\u059b\uaa61\u41ac\u6b47\u{1f701}', |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: -438.2, g: -306.1, b: 937.9, a: 0.4017, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer20, 'uint16', 6, 1); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(3, buffer31, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 16, new Uint32Array(17147).map((_, i) => i * 8), 684, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 56, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 591, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture42 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView34 = texture22.createView({}); |
| let renderPassEncoder2 = commandEncoder41.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: -121.5, g: 372.1, b: 295.3, a: -494.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(4, buffer17, 12, 0); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToBuffer(buffer27, 32, buffer29, 36, 4); |
| } catch {} |
| let querySet2 = device0.createQuerySet({type: 'timestamp', count: 9}); |
| let textureView35 = texture3.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline0); |
| } catch {} |
| let textureView36 = texture37.createView({}); |
| let computePassEncoder17 = commandEncoder15.beginComputePass(); |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 344, new Uint32Array(5216).map((_, i) => i * 8), 28, 116); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| requires pointer_composite_access; |
| |
| diagnostic(info, xyz); |
| |
| struct FragmentOutput0 { |
| @location(0) location_0: vec4f, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(0) @binding(133) var<storage, read> buffer35: array<array<array<array<array<array<array<array<array<array<f16, 7>, 1>, 1>, 1>, 1>, 1>, 1>, 8>, 8>, 1>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T0 { |
| @size(128) f0: array<atomic<i32>, 1>, |
| f1: array<f16>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput8 { |
| @builtin(instance_index) instance_index: u32, |
| @location(7) @interpolate(flat, either) location_7: vec4i, |
| @location(6) location_6: vec4h, |
| @location(3) location_3: u32, |
| } |
| |
| struct VertexInput10 { |
| @location(4) location_4: vec4u, |
| @location(15) location_15: vec2i, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<private> vp2: vec2h = vec2h(23005.3, 10147.6); |
| |
| struct VertexInput9 { |
| @location(5) @interpolate(linear) location_5: vec2f, |
| @location(10) @interpolate(flat) location_10: vec4i, |
| @location(2) @interpolate(flat, centroid) location_2: vec2i, |
| @location(8) location_8: f16, |
| @location(12) location_12: vec2h, |
| } |
| |
| var<private> vp1: vec2h = vec2h(3790.6, 4454.0); |
| |
| struct VertexInput7 { |
| @location(9) location_9: f16, |
| } |
| |
| struct ComputeInput6 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp0: vec4i = vec4i(324850404, 485562310, 299332112, 197942101); |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex1(a0: VertexInput7, a1: VertexInput8, @location(13) @interpolate(flat) location_13: vec2i, @location(0) @interpolate(linear, centroid) location_0: vec4f, @builtin(vertex_index) vertex_index: u32, @location(1) location_1: vec4i, a6: VertexInput9, a7: VertexInput10, @location(14) @interpolate(flat) location_14: i32, @location(11) @interpolate(linear) location_11: vec2f) -> @builtin(position) vec4f { |
| var out: vec4f; |
| let vf25: vec2h = atan2(vec2h(acos(vec2f(unconst_f32(0.04371e-16), unconst_f32(0.3559e-28))).rr), vec2h(unconst_f16(186.8), unconst_f16(11086.5))); |
| let vf26: u32 = a1.instance_index; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| out.location_0 = vec4f(f32(acosh(vec4h(out.location_0)[3]))); |
| var vf27: f16 = distance(vec4h(unconst_f16(7475.3), unconst_f16(8576.6), unconst_f16(634.9), unconst_f16(4424.9)), vec4h(unconst_f16(1070.8), unconst_f16(13862.8), unconst_f16(15012.3), unconst_f16(1045.1))); |
| vp2 = vp2; |
| let ptr13: ptr<function, vec4f> = &out.location_0; |
| let ptr14: ptr<private, vec2h> = &vp2; |
| vp2 = vec2h(unpack2x16snorm(unconst_u32(258247841)).gg); |
| for (var it0=bitcast<u32>(vp2); it0<(bitcast<u32>(vp2) & 0xfff); it0++) { |
| vp2 = bitcast<vec2h>(out.location_0[unconst_u32(298303456)]); |
| let vf28: vec4f = exp2(vec4f(unconst_f32(0.01907e13), unconst_f32(0.04860e-37), unconst_f32(0.01911e-32), unconst_f32(0.2089))); |
| out.location_0 = out.location_0; |
| vp1 = vec2h(atan2(vec2f(bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(257865268), unconst_i32(1683384060), unconst_i32(714942401), unconst_i32(32869110))))), vec2f(unconst_f32(0.1284), unconst_f32(0.03059))).rr.xx); |
| var vf29: vec4f = unpack4x8unorm(unconst_u32(605038190)); |
| var vf30: vec3h = faceForward(vec3h(unconst_f16(659.1), unconst_f16(18279.6), unconst_f16(1004.3)), vec3h(unconst_f16(7360.2), unconst_f16(14629.7), unconst_f16(5540.6)), vec3h(unconst_f16(5520.9), unconst_f16(3938.6), unconst_f16(15336.3))); |
| break; |
| } |
| let vf31: vec4u = firstLeadingBit(vec4u(unconst_u32(767179241), unconst_u32(419060594), unconst_u32(67355233), unconst_u32(135271756))); |
| out.location_0 = vec4f((*ptr14).rgrg.yzzw); |
| var vf32: f32 = (*ptr13)[unconst_u32(1466188852)]; |
| let ptr15: ptr<function, vec4f> = &out.location_0; |
| return out; |
| } |
| |
| /* used global variables: buffer35 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute3(@builtin(local_invocation_index) local_invocation_index: u32, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, a3: ComputeInput6) { |
| let ptr16: ptr<storage, array<f16, 7>, read> = &buffer35[unconst_u32(497496418)][7][unconst_u32(171769503)][unconst_u32(87668145)][0][0][0][0][unconst_u32(10870526)]; |
| { |
| let ptr17: ptr<storage, array<f16, 7>, read> = &buffer35[0][unconst_u32(1166887837)][unconst_u32(449614251)][unconst_u32(55567734)][0][unconst_u32(857336879)][0][unconst_u32(3412691033)][unconst_u32(1568902094)]; |
| vp2 -= vec2h((*&buffer35)[unconst_u32(387434464)][unconst_u32(1472575072)][7][0][0][unconst_u32(392002950)][0][0][unconst_u32(1099443403)][6]); |
| vp0 = vec4i(i32(buffer35[0][unconst_u32(347740954)][7][0][0][0][0][0][0][6])); |
| let ptr18: ptr<storage, array<array<f16, 7>, 1>, read> = &(*&buffer35)[0][unconst_u32(33945254)][7][u32((*&buffer35)[unconst_u32(251690893)][unconst_u32(339410633)][u32(buffer35[0][unconst_u32(498136484)][7][0][0][0][unconst_u32(86346387)][unconst_u32(998090404)][0][6])][0][unconst_u32(31435573)][unconst_u32(167953447)][0][0][unconst_u32(472076646)][6])][unconst_u32(366887575)][0][unconst_u32(2323409824)][0]; |
| let ptr19: ptr<storage, f16, read> = &buffer35[unconst_u32(517931254)][unconst_u32(608256165)][7][0][unconst_u32(1981561216)][0][0][0][unconst_u32(122038429)][unconst_u32(242576783)]; |
| _ = buffer35; |
| } |
| vp1 -= vec2h(buffer35[0][7][unconst_u32(474566509)][unconst_u32(986217831)][0][0][unconst_u32(384547960)][0][0][6]); |
| vp2 = vec2h((*&buffer35)[0][unconst_u32(3229397270)][unconst_u32(590966221)][unconst_u32(751164631)][0][unconst_u32(269300408)][0][0][0][unconst_u32(1094906398)]); |
| let ptr20: ptr<storage, f16, read> = &(*&buffer35)[0][7][7][0][unconst_u32(346879912)][0][u32((*&buffer35)[unconst_u32(559572215)][7][7][unconst_u32(1263783462)][unconst_u32(1634030328)][0][unconst_u32(244663667)][0][0][unconst_u32(1674948670)])][unconst_u32(442923764)][unconst_u32(249553873)][6]; |
| vp1 = vec2h(buffer35[0][unconst_u32(51088266)][7][0][0][unconst_u32(595296415)][unconst_u32(465864781)][unconst_u32(216947453)][0][6]); |
| vp2 = vec2h((*&buffer35)[0][7][7][0][0][0][0][0][unconst_u32(191895082)][6]); |
| let ptr21: ptr<storage, f16, read> = &buffer35[0][7][unconst_u32(63081291)][0][unconst_u32(101961729)][unconst_u32(3067073052)][unconst_u32(375945412)][0][0][6]; |
| while bool((*&buffer35)[0][7][7][unconst_u32(1088412286)][0][0][unconst_u32(4439883)][unconst_u32(8980173)][0][unconst_u32(169721321)]) { |
| let ptr22: ptr<storage, f16, read> = &buffer35[unconst_u32(1559096204)][u32((*&buffer35)[0][unconst_u32(1243319364)][7][unconst_u32(354062868)][0][unconst_u32(341013872)][0][0][0][6])][unconst_u32(776104999)][0][unconst_u32(1792522550)][0][0][0][unconst_u32(257936338)][6]; |
| vp2 += vec2h((*&buffer35)[0][unconst_u32(98055382)][7][unconst_u32(163251106)][0][0][unconst_u32(272916932)][unconst_u32(272472255)][unconst_u32(1417823705)][6]); |
| vp0 -= vec4i(i32((*&buffer35)[unconst_u32(1322184210)][7][unconst_u32(613281498)][unconst_u32(842712440)][unconst_u32(4294967295)][0][unconst_u32(492277992)][0][0][6])); |
| _ = buffer35; |
| } |
| { |
| for (var it2=u32((*&buffer35)[0][7][7][0][unconst_u32(245368811)][0][0][0][0][6]); it2<(u32((*&buffer35)[unconst_u32(537803147)][7][unconst_u32(1969167180)][u32(buffer35[0][unconst_u32(1680253692)][unconst_u32(701556766)][unconst_u32(66527226)][0][0][0][unconst_u32(813991418)][0][6])][0][unconst_u32(377098306)][unconst_u32(272686315)][unconst_u32(728064097)][unconst_u32(462442781)][6]) & 0xfff); it2++) { |
| vp2 = vec2h(buffer35[unconst_u32(1091991758)][u32((*&buffer35)[0][7][7][unconst_u32(83850387)][0][unconst_u32(469653672)][unconst_u32(418083503)][0][0][6])][7][u32(buffer35[0][unconst_u32(273390651)][7][0][0][0][0][unconst_u32(241659015)][0][6])][0][0][unconst_u32(289349550)][unconst_u32(1004281362)][0][6]); |
| let ptr23: ptr<storage, array<f16, 7>, read> = &(*&buffer35)[0][7][7][0][0][unconst_u32(601699171)][unconst_u32(952505949)][0][0]; |
| let ptr24: ptr<storage, array<f16, 7>, read> = &(*&buffer35)[unconst_u32(927026979)][7][u32(buffer35[unconst_u32(73555442)][7][7][0][0][unconst_u32(204681698)][0][0][unconst_u32(409632717)][6])][unconst_u32(152035572)][unconst_u32(1003822309)][0][0][0][0]; |
| for (var it1=u32(buffer35[unconst_u32(27724480)][7][unconst_u32(637906294)][0][0][0][0][0][unconst_u32(847240823)][6]); it1<(u32(buffer35[0][7][7][0][0][unconst_u32(1817833896)][unconst_u32(539730426)][0][unconst_u32(335074166)][unconst_u32(2115518487)]) & 0xfff); it1++) { |
| vp1 += vec2h(buffer35[unconst_u32(945462512)][unconst_u32(982035767)][7][0][0][0][unconst_u32(1285119451)][0][0][6]); |
| _ = buffer35; |
| } |
| break; |
| _ = buffer35; |
| } |
| let ptr25: ptr<storage, array<f16, 7>, read> = &buffer35[unconst_u32(547918519)][unconst_u32(589351260)][7][unconst_u32(405537912)][0][0][0][0][unconst_u32(1389091091)]; |
| let ptr26: ptr<storage, f16, read> = &(*&buffer35)[0][unconst_u32(51880206)][7][unconst_u32(37885357)][unconst_u32(34088442)][0][unconst_u32(334246473)][unconst_u32(393969395)][unconst_u32(104385365)][6]; |
| let ptr27: ptr<storage, f16, read> = &(*&buffer35)[0][7][7][unconst_u32(541782948)][u32((*&buffer35)[0][7][unconst_u32(1385228555)][u32((*&buffer35)[unconst_u32(11857772)][7][7][0][unconst_u32(289214957)][0][0][0][0][6])][0][unconst_u32(1481486969)][unconst_u32(607432105)][0][0][6])][unconst_u32(298076701)][unconst_u32(338191903)][0][0][unconst_u32(250472584)]; |
| vp1 = vec2h(buffer35[unconst_u32(475063846)][7][u32(buffer35[unconst_u32(1252684284)][unconst_u32(72712898)][7][unconst_u32(1079375255)][0][0][unconst_u32(140903536)][unconst_u32(461868151)][0][u32((*&buffer35)[0][unconst_u32(509225164)][7][unconst_u32(404696400)][unconst_u32(1155989030)][unconst_u32(718335232)][unconst_u32(257862008)][0][0][6])])][0][0][unconst_u32(211549684)][0][unconst_u32(248970432)][unconst_u32(1388116789)][6]); |
| _ = buffer35; |
| } |
| _ = buffer35; |
| }`, |
| }); |
| let buffer37 = device0.createBuffer({size: 12444, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let textureView37 = texture42.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer20, 'uint32', 4, 2); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1040 */ |
| offset: 1040, |
| buffer: buffer37, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| let buffer38 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder13.insertDebugMarker('\u43cb'); |
| } catch {} |
| let commandEncoder49 = device0.createCommandEncoder(); |
| let computePassEncoder18 = commandEncoder20.beginComputePass(); |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup15, new Uint32Array(746), 237, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(0, buffer0, 0, 0); |
| } catch {} |
| let commandEncoder50 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer12); |
| } catch {} |
| let textureView38 = texture12.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 6}); |
| try { |
| computePassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer20, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup15, new Uint32Array(1425), 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(6, buffer7, 832, 7_852); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let buffer39 = device0.createBuffer({ |
| size: 97, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView39 = texture9.createView({aspect: 'all', format: 'rgba16sint'}); |
| let renderPassEncoder3 = commandEncoder27.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 138.3, g: -341.0, b: -9.012, a: 139.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(210), 8, 0); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToBuffer(buffer29, 24, buffer39, 0, 24); |
| } catch {} |
| try { |
| renderPassEncoder3.insertDebugMarker('\u5209'); |
| } catch {} |
| await gc(); |
| let buffer40 = device0.createBuffer({size: 240, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder51 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup5, []); |
| } catch {} |
| try { |
| renderPassEncoder1.setStencilReference(1917); |
| } catch {} |
| try { |
| commandEncoder21.resolveQuerySet(querySet1, 62, 0, buffer0, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 32, new DataView(new Uint8Array(7542).map((_, i) => i).buffer), 4935, 12); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let texture43 = device0.createTexture({ |
| size: [30, 1, 79], |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView40 = texture4.createView({format: 'rgba16sint'}); |
| let renderPassEncoder4 = commandEncoder50.beginRenderPass({ |
| colorAttachments: [{view: textureView31, loadOp: 'clear', storeOp: 'store'}], |
| maxDrawCount: 627752794, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup6, []); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| document.body.append(canvas0); |
| await gc(); |
| let computePassEncoder19 = commandEncoder37.beginComputePass(); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(5); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer38, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer39, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 28, new Uint32Array(8419).map((_, i) => i * 10), 2709, 0); |
| } catch {} |
| await gc(); |
| let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(2); |
| let commandEncoder52 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 12, new Uint32Array(8504).map((_, i) => i * 3), 3267, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let textureView41 = texture25.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder1.setVertexBuffer(6, buffer39, 0, 6); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3948 */ |
| offset: 3948, |
| buffer: buffer7, |
| }, { |
| texture: texture29, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 5, y: 14 }, |
| flipY: false, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let textureView42 = texture17.createView({dimension: '2d', baseArrayLayer: 4}); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(1007), 4, 0); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer11, 'uint32', 0, 4); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer12, 136, 21); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer34, 'uint16', 0, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 33, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| offscreenCanvas0.height = 416; |
| let buffer41 = device0.createBuffer({size: 216, usage: GPUBufferUsage.COPY_DST}); |
| let texture44 = device0.createTexture({ |
| size: {width: 15, height: 1, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView43 = texture43.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer27, 0, 18); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer6, 'uint32', 0, 16); |
| } catch {} |
| let pipeline1 = device0.createRenderPipeline({ |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-dst-alpha'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-constant'}, |
| }, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| buffers: [ |
| { |
| arrayStride: 16, |
| attributes: [ |
| {format: 'sint8x4', offset: 0, shaderLocation: 13}, |
| {format: 'sint32', offset: 0, shaderLocation: 10}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 1}, |
| {format: 'uint32', offset: 4, shaderLocation: 4}, |
| {format: 'float32x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 15}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 14}, |
| {format: 'float16x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 2}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 7}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 3}, |
| {format: 'float16x2', offset: 0, shaderLocation: 6}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 0}, |
| {format: 'float16x4', offset: 0, shaderLocation: 11}, |
| {format: 'snorm8x2', offset: 2, shaderLocation: 5}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'front'}, |
| }); |
| let imageData3 = new ImageData(4, 44); |
| try { |
| canvas0.getContext('webgl'); |
| } catch {} |
| let buffer42 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_DST}); |
| try { |
| renderBundleEncoder5.setVertexBuffer(2, buffer31, 32, 5); |
| } catch {} |
| let texture45 = device0.createTexture({ |
| size: {width: 1, height: 540, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let bindGroup16 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 56, resource: textureView1}, |
| {binding: 8, resource: textureView18}, |
| {binding: 591, resource: textureView38}, |
| {binding: 1, resource: textureView39}, |
| ], |
| }); |
| let renderPassEncoder5 = commandEncoder9.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView42, |
| clearValue: { r: 418.1, g: 283.9, b: -809.9, a: 465.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| device0.queue.writeBuffer(buffer7, 7_324, new Uint32Array(3915).map((_, i) => i * 8), 577, 128); |
| } catch {} |
| let buffer43 = device0.createBuffer({size: 115, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let textureView44 = texture37.createView({}); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup2, new Uint32Array(7), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer38, 'uint16', 12, 3); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let pipeline2 = await device0.createComputePipelineAsync({ |
| layout: pipelineLayout1, |
| compute: {module: shaderModule1, entryPoint: 'compute1', constants: {28_210: 1}}, |
| }); |
| document.body.append(canvas0); |
| let recycledExplicitBindGroupLayout2 = pipeline2.getBindGroupLayout(1); |
| let commandEncoder54 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup7, new Uint32Array(5784), 988, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer38, 'uint16', 6, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer37.unmap(); |
| } catch {} |
| try { |
| commandEncoder54.resolveQuerySet(querySet2, 0, 0, buffer3, 0); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let buffer44 = device0.createBuffer({size: 272, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let textureView45 = texture28.createView({}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline1); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let textureView46 = texture10.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(1, buffer31); |
| } catch {} |
| let renderPassEncoder6 = commandEncoder13.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView43, |
| depthSlice: 48, |
| clearValue: { r: 363.0, g: 950.2, b: 259.5, a: 414.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 46246867, |
| }); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup7, new Uint32Array(2354), 43, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 1, y: 21 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer20, 'uint16', 2, 2); |
| } catch {} |
| let pipeline3 = device0.createRenderPipeline({ |
| layout: pipelineLayout3, |
| fragment: {module: shaderModule2, targets: [{format: 'bgra8unorm'}]}, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 1}, |
| {format: 'unorm8x2', offset: 2, shaderLocation: 6}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 0}, |
| {format: 'float32x2', offset: 0, shaderLocation: 8}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 3}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 12}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 4}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 2}, |
| {format: 'float32x2', offset: 0, shaderLocation: 9}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 7}, |
| {format: 'float32x4', offset: 0, shaderLocation: 5}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 32, |
| attributes: [{format: 'sint32', offset: 0, shaderLocation: 10}, {format: 'sint8x2', offset: 2, shaderLocation: 13}], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let texture46 = device0.createTexture({ |
| size: {width: 1, height: 1080, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder20 = commandEncoder31.beginComputePass(); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer42, 8, new Float32Array(13142).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.256)), 1325, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte240m', transfer: 'hlg'} }); |
| try { |
| computePassEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, buffer31); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer29, 84, buffer13, 20, 0); |
| } catch {} |
| let buffer45 = device0.createBuffer({size: 44, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let sampler9 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'linear', lodMaxClamp: 44.64}); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup13, new Uint32Array(146), 38, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer34, 'uint16', 0, 1); |
| } catch {} |
| try { |
| commandEncoder35.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 23, y: 12, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 591, resource: textureView6}, |
| {binding: 56, resource: textureView0}, |
| {binding: 1, resource: textureView39}, |
| {binding: 8, resource: textureView18}, |
| ], |
| }); |
| let computePassEncoder21 = commandEncoder30.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 588, endOfPassWriteIndex: 101}}); |
| try { |
| computePassEncoder21.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(4, buffer7, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer41, 8, new Float32Array(14748).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4810)), 10077, 8); |
| } catch {} |
| let pipeline4 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-src'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint8x2', offset: 0, shaderLocation: 15}, |
| {format: 'uint32', offset: 0, shaderLocation: 3}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 1}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 2}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 14}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 7}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12}, |
| {format: 'float16x2', offset: 0, shaderLocation: 8}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 4}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 9}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 6}, |
| ], |
| }, |
| {arrayStride: 4, stepMode: 'vertex', attributes: [{format: 'float32', offset: 0, shaderLocation: 5}]}, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw'}, |
| }); |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 1, resource: textureView21}, |
| {binding: 56, resource: textureView0}, |
| {binding: 8, resource: textureView7}, |
| {binding: 591, resource: textureView6}, |
| ], |
| }); |
| let buffer46 = device0.createBuffer({ |
| size: 40, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder57 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup14, new Uint32Array(2284), 381, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer4, 8, 11); |
| } catch {} |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(1, bindGroup8, new Uint32Array(384), 221, 0); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 1_244, new Float32Array(6550).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.484)), 232, 1072); |
| } catch {} |
| let texture47 = device0.createTexture({ |
| size: [30], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup4, new Uint32Array(2525), 828, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(2, buffer20, 0, 0); |
| } catch {} |
| try { |
| commandEncoder54.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2296 */ |
| offset: 2296, |
| bytesPerRow: 6144, |
| buffer: buffer7, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder18.insertDebugMarker('\u{1f77f}'); |
| } catch {} |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup7, new Uint32Array(955), 426, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 20, new Uint32Array(1464).map((_, i) => i * 2), 12, 4); |
| } catch {} |
| let buffer47 = device0.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| let promise9 = shaderModule1.getCompilationInfo(); |
| let arrayBuffer0 = buffer46.getMappedRange(); |
| try { |
| commandEncoder58.insertDebugMarker('\u9f2a'); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 133, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder60 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 48, new DataView(new Uint8Array(474).map((_, i) => i).buffer), 211, 0); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let textureView47 = texture9.createView({mipLevelCount: 1}); |
| let renderPassEncoder7 = commandEncoder61.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView43, |
| depthSlice: 77, |
| clearValue: { r: -21.74, g: -277.4, b: 621.7, a: 895.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer19, 'uint32', 0, 8); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(4, buffer39, 4, 4); |
| } catch {} |
| try { |
| commandEncoder39.label = '\ud00a\u9376\uafea\uf391\u7fa4\u0bf2\u059b'; |
| } catch {} |
| let texture48 = device0.createTexture({ |
| size: {width: 90, height: 24, depthOrArrayLayers: 231}, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView48 = texture3.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder1.beginOcclusionQuery(6); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let sampler10 = device0.createSampler({lodMinClamp: 48.26, lodMaxClamp: 53.42}); |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(3, buffer20); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 75, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 1, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder62 = device0.createCommandEncoder(); |
| let texture49 = device0.createTexture({ |
| size: {width: 18, height: 1, depthOrArrayLayers: 69}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup15); |
| } catch {} |
| let pipeline5 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2}}); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(149); }; |
| } catch {} |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let texture50 = device0.createTexture({ |
| size: [75, 1, 1], |
| mipLevelCount: 4, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture51 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup10, new Uint32Array(2583), 465, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer48 = device0.createBuffer({ |
| size: 196, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture52 = device0.createTexture({ |
| size: [1, 135, 1], |
| mipLevelCount: 2, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture53 = device0.createTexture({ |
| size: {width: 37, height: 1, depthOrArrayLayers: 45}, |
| mipLevelCount: 2, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder22 = commandEncoder28.beginComputePass(); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder1.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(5, buffer17, 4, 19); |
| } catch {} |
| document.body.append(canvas0); |
| try { |
| adapter0.label = '\u032a\u60ef\u{1fca5}\u9eb3\u0a40\u{1fe4f}\u{1f7a4}\u0727\u0d14'; |
| } catch {} |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({ |
| size: {width: 75, height: 1, depthOrArrayLayers: 32}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder22.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup7, new Uint32Array(2684), 1_004, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup7, new Uint32Array(1320), 654, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(5, buffer7, 2_488, 1_661); |
| } catch {} |
| let commandEncoder65 = device0.createCommandEncoder(); |
| let texture55 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470bg', transfer: 'bt2020_10bit'} }); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 515, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 529, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let texture56 = device0.createTexture({ |
| size: {width: 45, height: 12, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder6.setVertexBuffer(2, buffer7, 2_016, 1_112); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup10); |
| } catch {} |
| let pipeline6 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute2', constants: {}}}); |
| let texture57 = device0.createTexture({ |
| size: [64, 64, 18], |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(2917), 469, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer20, 'uint32', 0, 0); |
| } catch {} |
| try { |
| globalThis.someLabel = buffer18.label; |
| } catch {} |
| let textureView49 = texture57.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 6}); |
| let textureView50 = texture20.createView({}); |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup9, new Uint32Array(66), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer11, 'uint32', 8, 2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let recycledExplicitBindGroupLayout3 = pipeline0.getBindGroupLayout(2); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let texture58 = device0.createTexture({ |
| size: [90, 24, 5], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView51 = texture24.createView({}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer27); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let textureView52 = texture57.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6}); |
| let texture59 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder15.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder62.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2024 */ |
| offset: 2024, |
| rowsPerImage: 349, |
| buffer: buffer33, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 0, y: 33, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 0, new Float32Array(12996).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.430)), 702, 24); |
| } catch {} |
| let buffer49 = device0.createBuffer({size: 9416, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(59), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer48, 'uint16', 12, 8); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer27, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(0, buffer7, 1_072, 5_562); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture60 = device0.createTexture({ |
| size: [75, 1, 1], |
| mipLevelCount: 1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView53 = texture54.createView({dimension: '2d', baseArrayLayer: 3}); |
| try { |
| buffer29.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 16, new Uint32Array(37128).map((_, i) => i * 3), 2366, 0); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| document.body.append(canvas0); |
| let textureView54 = texture57.createView({format: 'depth24plus-stencil8', baseArrayLayer: 1, arrayLayerCount: 7}); |
| let texture61 = device0.createTexture({ |
| size: [37, 1, 32], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| await gc(); |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup19 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout2, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup19, new Uint32Array(2334), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer19, 'uint16', 34, 77); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup5, new Uint32Array(853), 111, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, alphaMode: 'opaque'}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(206).fill(128), /* required buffer size: 206 */ |
| {offset: 206, rowsPerImage: 32}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup20 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer49}}, |
| {binding: 529, resource: textureView5}, |
| {binding: 1, resource: {buffer: buffer49}}, |
| {binding: 515, resource: sampler0}, |
| {binding: 100, resource: {buffer: buffer19, size: 135}}, |
| ], |
| }); |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let querySet3 = device0.createQuerySet({type: 'timestamp', count: 494}); |
| let renderPassEncoder8 = commandEncoder46.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView43, |
| depthSlice: 8, |
| clearValue: { r: -598.1, g: 606.4, b: 255.5, a: -757.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 8}, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup19, new Uint32Array(2413), 104, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer3, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 9}, |
| aspect: 'all', |
| }, new Uint8Array(14_252).fill(210), /* required buffer size: 14_252 */ |
| {offset: 77, bytesPerRow: 75, rowsPerImage: 21}, {width: 17, height: 0, depthOrArrayLayers: 10}); |
| } catch {} |
| let imageData4 = new ImageData(60, 4); |
| let textureView55 = texture52.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1}); |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let pipeline7 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| fragment: { |
| module: shaderModule2, |
| constants: {}, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst-alpha'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 4, |
| attributes: [ |
| {format: 'sint8x4', offset: 0, shaderLocation: 1}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 12}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 7}, |
| {format: 'float32', offset: 0, shaderLocation: 13}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 14}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 2}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 4}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 9}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 0}, |
| {format: 'float16x2', offset: 0, shaderLocation: 6}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 3}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 8}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 10}, |
| {format: 'sint32', offset: 0, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'back'}, |
| }); |
| let texture62 = device0.createTexture({ |
| size: [45, 12, 115], |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView56 = texture17.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| try { |
| renderBundleEncoder8.setPipeline(pipeline3); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let pipeline8 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'bgra8unorm', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 180, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'unorm8x2', offset: 58, shaderLocation: 8}, |
| {format: 'float16x4', offset: 24, shaderLocation: 11}, |
| {format: 'sint16x4', offset: 68, shaderLocation: 5}, |
| {format: 'uint32x4', offset: 140, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 8, shaderLocation: 6}, |
| {format: 'float32x3', offset: 20, shaderLocation: 13}, |
| {format: 'float16x4', offset: 4, shaderLocation: 2}, |
| {format: 'uint32x2', offset: 44, shaderLocation: 4}, |
| {format: 'sint32x4', offset: 16, shaderLocation: 15}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 1}, |
| {format: 'snorm8x4', offset: 28, shaderLocation: 9}, |
| {format: 'unorm8x4', offset: 12, shaderLocation: 3}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'float32x4', offset: 852, shaderLocation: 0}, |
| {format: 'uint16x2', offset: 712, shaderLocation: 12}, |
| {format: 'unorm8x4', offset: 144, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 28, shaderLocation: 7}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let bindGroup21 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let texture63 = device0.createTexture({ |
| size: [22, 6, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup21, new Uint32Array(1634), 128, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let texture64 = device0.createTexture({ |
| size: [18], |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer4, 0, 54); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 8, new DataView(new ArrayBuffer(38644)), 624, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let texture65 = device0.createTexture({ |
| size: [18, 1, 251], |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rgba8unorm-srgb'], |
| }); |
| let computePassEncoder23 = commandEncoder69.beginComputePass(); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup19, new Uint32Array(808), 87, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(2, buffer12, 64, 92); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer48, 'uint16', 26, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline7); |
| } catch {} |
| let recycledExplicitBindGroupLayout4 = pipeline5.getBindGroupLayout(0); |
| let buffer50 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_SRC}); |
| let texture66 = device0.createTexture({ |
| size: {width: 1, height: 135, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture67 = device0.createTexture({ |
| size: {width: 30}, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView57 = texture63.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup21, new Uint32Array(3158), 551, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let buffer51 = device0.createBuffer({size: 376, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture68 = device0.createTexture({ |
| size: {width: 1}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup21, new Uint32Array(1069), 129, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup14, new Uint32Array(372), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer38, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 4, new Uint16Array(3542).map((_, i) => i + 4), 283, 56); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let imageData5 = new ImageData(36, 56); |
| let querySet4 = device0.createQuerySet({type: 'timestamp', count: 376}); |
| let renderPassEncoder9 = commandEncoder62.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView42, |
| clearValue: { r: 943.6, g: -376.9, b: -188.4, a: -172.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 714}, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup21, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer9, 0); }; |
| } catch {} |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup21, new Uint32Array(5610), 520, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(2, 10, 5, 1_309_932_707); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer48, 28); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer48, 16); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline7); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| struct T1 { |
| f0: array<atomic<u32>>, |
| } |
| |
| @group(3) @binding(8) var st1: texture_storage_3d<rg32float, read>; |
| |
| struct VertexInput16 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct VertexInput11 { |
| @location(14) location_14: vec4u, |
| @location(12) location_12: f16, |
| @location(3) location_3: vec2f, |
| @location(5) location_5: vec4u, |
| @location(8) location_8: f32, |
| } |
| |
| struct VertexInput13 { |
| @location(15) location_15: vec2u, |
| @location(11) @interpolate(linear) location_11: f32, |
| } |
| |
| @group(0) @binding(7) var<storage, read> buffer52: array<array<array<array<array<f16, 9>, 1>, 1>, 20>>; |
| |
| @group(1) @binding(4) var<storage, read_write> buffer55: array<array<array<array<array<VertexInput14, 13>, 1>, 1>, 16>>; |
| |
| override override1 = -62607995; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @id(10362) override override2: u32; |
| |
| struct VertexInput12 { |
| @location(7) @interpolate(flat) location_7: u32, |
| @location(1) @interpolate(flat) location_1: vec4i, |
| } |
| |
| struct ComputeInput8 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| @id(22737) override override3: i32; |
| |
| struct ComputeInput7 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput1 { |
| @location(1) location_1: vec4i, |
| @location(15) location_15: vec4h, |
| @location(6) location_6: u32, |
| @location(9) location_9: vec2h, |
| @location(3) location_3: i32, |
| @location(14) @interpolate(flat, first) location_14: u32, |
| @location(10) @interpolate(flat, first) location_10: vec2f, |
| @location(0) location_0: vec2u, |
| @location(7) location_7: i32, |
| @location(13) location_13: vec2i, |
| @location(2) location_2: vec4f, |
| @location(8) @interpolate(linear, center) location_8: vec4f, |
| @location(4) location_4: vec4f, |
| @invariant @builtin(position) position: vec4f, |
| @location(5) @interpolate(flat, centroid) location_5: f32, |
| } |
| |
| struct T2 { |
| @align(64) @size(128) f0: vec4u, |
| @size(192) f1: array<T0, 1>, |
| @size(640) f2: T0, |
| f3: array<u32>, |
| } |
| |
| var<workgroup> vw0: f16; |
| |
| struct T0 { |
| @align(8) @size(8) f0: bool, |
| @size(80) f1: vec2f, |
| } |
| |
| struct VertexInput14 { |
| @location(13) location_13: f16, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput15 { |
| @location(9) location_9: vec2u, |
| } |
| |
| @group(0) @binding(191) var<uniform> buffer53: array<array<vec4i, 4>, 79>; |
| |
| override override4: u32 = (519340439 % 103) + 1; |
| |
| @group(2) @binding(133) var<storage, read> buffer57: array<VertexInput14, 448>; |
| |
| /* used global variables: buffer53, tex0 */ |
| @must_use |
| fn fn0() -> bool { |
| var out: bool; |
| while bool(insertBits(unconst_i32(1206713723), unconst_i32(2147483647), unconst_u32(224360159), unconst_u32(2328993))) { |
| if bool(((*&buffer53)[78][unconst_u32(562222850)].bgg << vec3u(unconst_u32(1569138412), unconst_u32(929563496), unconst_u32(990296466)))[1]) { |
| out = bool(asinh(f16(unpack2x16unorm(unconst_u32(928664303)).y))); |
| let ptr28: ptr<uniform, vec4i> = &(*&buffer53)[78][3]; |
| let vf33: ptr<uniform, array<array<vec4i, 4>, 79>> = &buffer53; |
| _ = buffer53; |
| } |
| let vf34: vec4i = insertBits(vec4i(unconst_i32(190916479), unconst_i32(342555468), unconst_i32(73880445), unconst_i32(292869886)), vec4i(unconst_i32(247583678), unconst_i32(451670365), unconst_i32(341507247), unconst_i32(134717840)), u32(all((vec2i(unconst_i32(838955976), unconst_i32(6890456)) > vec2i(i32(override4))))), unconst_u32(7183268)); |
| out = bool(max(vec2i(unconst_i32(196596291), unconst_i32(676187781)), buffer53[78][unconst_u32(327387850)].zw)[0]); |
| let vf35: u32 = pack4xU8(vec4u(unconst_u32(793733882), unconst_u32(538419953), unconst_u32(224642975), unconst_u32(792795794))); |
| _ = override4; |
| _ = buffer53; |
| } |
| out = bool((*&buffer53)[78][3].w); |
| let vf36: vec2u = textureDimensions(tex0, unconst_i32(617106958)); |
| for (var it3=vec3u(atan(vec3h((*&buffer53)[unconst_u32(100255755)][3].abb)).gbb)[0]; it3<(bitcast<u32>((*&buffer53)[78][unconst_u32(572774688)][unconst_u32(403761971)]) & 0xfff); it3++) { |
| out = bool((*&buffer53)[78][3][2]); |
| var vf37: bool = (unconst_f32(-0.07426e5) != unconst_f32(0.2097e4)); |
| break; |
| _ = buffer53; |
| } |
| out = bool(acosh(vec2h(unconst_f16(4170.7), unconst_f16(-7363.9)))[1]); |
| switch bitcast<u32>(acosh(vec2h(unconst_f16(65500.0), unconst_f16(3987.1)))) { |
| default: { |
| let ptr29: ptr<uniform, vec4i> = &(*&buffer53)[unconst_u32(556675653)][3]; |
| _ = buffer53; |
| } |
| } |
| var vf38: i32 = (*&buffer53)[unconst_u32(274364274)][3][unconst_u32(236625052)]; |
| return out; |
| _ = override4; |
| _ = buffer53; |
| _ = tex0; |
| } |
| |
| @group(0) @binding(2) var tex0: texture_cube_array<u32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* used global variables: buffer52 */ |
| @vertex |
| fn vertex2(@location(0) location_0: vec4u, a1: VertexInput11, a2: VertexInput12, @location(4) @interpolate(perspective, center) location_4: vec4f, @location(10) @interpolate(flat, center) location_10: vec2i, a5: VertexInput13, @location(2) @interpolate(linear, center) location_2: f16, a7: VertexInput14, a8: VertexInput15, @location(6) location_6: u32, a10: VertexInput16, @builtin(vertex_index) vertex_index: u32) -> VertexOutput1 { |
| var out: VertexOutput1; |
| out.location_0 &= vec2u(u32(buffer52[arrayLength(&buffer52)][unconst_u32(158513522)][unconst_u32(579247217)][0][8])); |
| return out; |
| _ = buffer52; |
| } |
| |
| /* used global variables: buffer53, buffer55, buffer57, tex0 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute4(a0: ComputeInput7, a1: ComputeInput8) { |
| buffer55[unconst_u32(863559412)][unconst_u32(151716210)][unconst_u32(414145517)][unconst_u32(2122418529)][unconst_u32(94221268)] = (*&buffer57)[447]; |
| _ = fn0(); |
| var vf39 = fn0(); |
| let ptr30: ptr<storage, VertexInput14, read_write> = &(*&buffer55)[arrayLength(&(*&buffer55))][u32(buffer57[447].location_13)][unconst_u32(591060340)][0][12]; |
| { |
| var vf40 = fn0(); |
| buffer55[unconst_u32(528770773)][unconst_u32(216005851)][pack4xU8(vec4u((*&buffer53)[78][3].yywy))][unconst_u32(4152712884)][unconst_u32(1516962126)] = VertexInput14(buffer55[unconst_u32(165254121)][unconst_u32(289083953)][unconst_u32(1047032798)][u32((*&buffer55)[arrayLength(&(*&buffer55)) - 1][15][0][0][12].location_13)][unconst_u32(3111189169)].location_13); |
| _ = fn0(); |
| _ = override4; |
| _ = tex0; |
| _ = buffer53; |
| _ = buffer55; |
| } |
| let ptr31: ptr<uniform, array<vec4i, 4>> = &(*&buffer53)[unconst_u32(94275097)]; |
| let ptr32: ptr<storage, f16, read_write> = &buffer55[unconst_u32(545084270)][unconst_u32(6911426)][0][0][12].location_13; |
| { |
| buffer55[unconst_u32(142956083)][unconst_u32(194455014)][0][u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(107751832)][0][0][12].location_13)][unconst_u32(169406544)] = (*&buffer55)[unconst_u32(392206179)][15][unconst_u32(553302732)][0][12]; |
| vw0 = (*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(800633095)][unconst_u32(90327584)][0][12].location_13; |
| vw0 = (*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(481024504)][unconst_u32(272356806)][0][12].location_13; |
| _ = buffer55; |
| } |
| buffer55[unconst_u32(109837762)][unconst_u32(24459874)][unconst_u32(1615197572)][unconst_u32(1386200310)][unconst_u32(839205252)].location_13 = buffer55[arrayLength(&buffer55)][pack4xI8Clamp(buffer53[78][u32(buffer55[unconst_u32(189816334)][unconst_u32(531075710)][unconst_u32(921932832)][bitcast<u32>(distance(vec4f(unconst_f32(0.3822e6), unconst_f32(0.7552e-37), unconst_f32(0.09118), unconst_f32(0.1975e-12)), vec4f(unconst_f32(0.3206e-3), unconst_f32(0.2150), unconst_f32(-0.08594), unconst_f32(0.03301e6))))][12].location_13)])][unconst_u32(212422806)][0][unconst_u32(488107469)].location_13; |
| var vf41 = fn0(); |
| _ = override4; |
| _ = tex0; |
| _ = buffer57; |
| _ = buffer55; |
| _ = buffer53; |
| } |
| |
| /* used global variables: buffer53, buffer55, buffer57, st1, tex0 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute5() { |
| let ptr33: ptr<storage, VertexInput14, read_write> = &buffer55[u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(98824504)][0][0][unconst_u32(1475765311)].location_13)][unconst_u32(691061498)][0][unconst_u32(530155561)][12]; |
| loop { |
| vw0 = buffer55[unconst_u32(2015096823)][15][unconst_u32(929733838)][unconst_u32(242675618)][12].location_13; |
| buffer55[unconst_u32(1572598292)][15][unconst_u32(381470439)][unconst_u32(603091388)][unconst_u32(1602520740)] = (*&buffer55)[arrayLength(&(*&buffer55))][15][unconst_u32(71423651)][0][12]; |
| let ptr34: ptr<storage, VertexInput14, read_write> = &(*&buffer55)[unconst_u32(400388205)][15][unconst_u32(1868003516)][0][unconst_u32(260447495)]; |
| break; |
| _ = buffer55; |
| } |
| _ = fn0(); |
| _ = fn0(); |
| var vf42 = fn0(); |
| for (var jj53=0u; jj53<3; jj53++) { buffer55[unconst_u32(343925879)][unconst_u32(405189601)][unconst_u32(2431418292)][jj53][unconst_u32(47224494)].location_13 = f16(buffer53[78][unconst_u32(1447232423)][unconst_u32(953821080)]); } |
| if bool((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(718952994)][unconst_u32(1106970167)][0][u32((*&buffer55)[unconst_u32(1779562586)][15][0][0][12].location_13)].location_13) { |
| _ = fn0(); |
| vw0 = f16(textureDimensions(st1)[0]); |
| vw0 = (*&buffer55)[unconst_u32(485409213)][unconst_u32(292233538)][0][unconst_u32(814683715)][unconst_u32(131293631)].location_13; |
| vw0 = (*&buffer55)[unconst_u32(928240422)][15][unconst_u32(1473443188)][unconst_u32(268272538)][unconst_u32(114441322)].location_13; |
| return; |
| _ = override4; |
| _ = buffer55; |
| _ = buffer53; |
| _ = tex0; |
| _ = st1; |
| } |
| vf42 = bool(buffer55[arrayLength(&buffer55)][u32((*&buffer55)[unconst_u32(156715298)][15][0][0][12].location_13)][0][0][unconst_u32(363408306)].location_13); |
| vf42 = bool((*&buffer55)[unconst_u32(338604410)][15][unconst_u32(78335694)][0][12].location_13); |
| buffer55[unconst_u32(1014133642)][unconst_u32(572905143)][unconst_u32(247945546)][unconst_u32(986406566)][unconst_u32(255190930)].location_13 = f16(textureDimensions(tex0, unconst_i32(1175188535))[0]); |
| for (var jj99=0u; jj99<3; jj99++) { buffer55[unconst_u32(1104354407)][unconst_u32(1034826593)][jj99][u32(buffer55[unconst_u32(58913035)][unconst_u32(877072180)][unconst_u32(782188642)][unconst_u32(2145524731)][unconst_u32(564597186)].location_13)][unconst_u32(235587711)].location_13 = (*&buffer55)[arrayLength(&(*&buffer55))][15][unconst_u32(149605685)][unconst_u32(74494132)][12].location_13; } |
| buffer55[unconst_u32(556401692)][u32((*&buffer55)[unconst_u32(3894152)][15][0][0][12].location_13)][u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(711024683)][0][unconst_u32(92093255)][unconst_u32(12981774)].location_13)][unconst_u32(1045536112)][unconst_u32(344485900)].location_13 -= buffer57[447].location_13; |
| _ = override4; |
| _ = buffer55; |
| _ = tex0; |
| _ = st1; |
| _ = buffer57; |
| _ = buffer53; |
| }`, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(2, 1, 0, 226_823_628); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 223, 0, 830_835_700, 75_388_281); |
| } catch {} |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder3.draw(4, 337, 0, 93_549_395); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer49, 536); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer20, 0); |
| } catch {} |
| let commandEncoder74 = device0.createCommandEncoder(); |
| let textureView58 = texture64.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(1, 55, 1, 474_751_921); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 66, 0, 149_451_718, 62_647_185); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer46, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup15, new Uint32Array(445), 23, 0); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| commandEncoder8.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2288 */ |
| offset: 2288, |
| buffer: buffer33, |
| }, { |
| texture: texture50, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder2.pushDebugGroup('\u0af1'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 18, height: 1, depthOrArrayLayers: 45} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture53, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 7}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext1 = canvas1.getContext('webgpu'); |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 529, resource: textureView46}, |
| {binding: 515, resource: sampler0}, |
| {binding: 1, resource: {buffer: buffer49}}, |
| {binding: 4, resource: {buffer: buffer49}}, |
| {binding: 100, resource: {buffer: buffer22, size: 151}}, |
| ], |
| }); |
| let texture69 = device0.createTexture({ |
| size: {width: 75}, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView59 = texture55.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let sampler11 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 81.94}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup19, new Uint32Array(5082), 329, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(6, buffer48, 12, 3); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| let commandEncoder75 = device0.createCommandEncoder(); |
| let texture70 = device0.createTexture({ |
| size: [90], |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView60 = texture37.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup19, new Uint32Array(1939), 194, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer49, 1_540); }; |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 191, 0, 1_010_478_020, 1_840_296_082); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer48, 28); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer49, 'uint32', 24, 914); |
| } catch {} |
| let imageData6 = new ImageData(88, 64); |
| let autogeneratedBindGroupLayout0 = pipeline6.getBindGroupLayout(0); |
| let texture71 = device0.createTexture({ |
| size: [18, 1, 820], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer9, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(508), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(1, 212, 1, 351_762_765); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer6, 0); |
| } catch {} |
| let pipeline9 = await promise5; |
| try { |
| await promise12; |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder4.label; |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 56, resource: textureView0}, |
| {binding: 591, resource: textureView38}, |
| {binding: 1, resource: textureView16}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer46, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let commandBuffer1 = commandEncoder10.finish(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup7, []); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 146, 0, -1_909_407_116, 119_068_996); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer6, 0); |
| } catch {} |
| let pipeline10 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x1e13b585}, |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst-alpha'}, |
| alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE, |
| }], |
| }, |
| vertex: { |
| module: shaderModule3, |
| buffers: [ |
| { |
| arrayStride: 44, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 0, shaderLocation: 15}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 3}, |
| {format: 'float32x3', offset: 12, shaderLocation: 13}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 14}, |
| {format: 'uint8x4', offset: 8, shaderLocation: 5}, |
| {format: 'float32', offset: 4, shaderLocation: 2}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 12}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 10}, |
| {format: 'float32x3', offset: 4, shaderLocation: 11}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint32x4', offset: 4, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 4, shaderLocation: 0}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 24, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'unorm16x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint8x2', offset: 10, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'ccw', cullMode: 'front'}, |
| }); |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(133) var<storage, read> buffer58: array<array<array<VertexInput17, 1>, 14>>; |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<workgroup, array<vec4f, 1>>, a1: vec2<bool>) { |
| { |
| for (var jj23=0u; jj23<3; jj23++) { (*a0)[jj23] = vec4f(mix(vec3h(unconst_f16(21065.5), unconst_f16(10790.5), unconst_f16(1637.0)), vec3h(f16(length(vec3f(unconst_f32(0.2198e-10), unconst_f32(0.03439e10), unconst_f32(0.2668e-2))))), vec3h(unconst_f16(14189.5), unconst_f16(17674.8), unconst_f16(19205.8))).rbbb.zwyw.ywxz); } |
| vp3[39] = modf(f16(all(vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false))))); |
| } |
| if bool(sinh(unconst_f32(0.3993e-37))) { |
| vp3[unconst_u32(1007660963)].whole = (mat4x4h() + mat4x4h(unconst_f16(24899.0), unconst_f16(13406.0), unconst_f16(1409.8), unconst_f16(1350.4), unconst_f16(37715.9), unconst_f16(11133.1), unconst_f16(8029.8), unconst_f16(14930.0), unconst_f16(14475.6), unconst_f16(5998.7), unconst_f16(6539.5), unconst_f16(9354.1), unconst_f16(1274.9), unconst_f16(5452.4), unconst_f16(23228.0), unconst_f16(25702.6)))[unconst_i32(2)][3]; |
| switch i32((*a0)[0].x) { |
| default: { |
| let ptr35 = &vp3[bitcast<u32>((*a0)[unconst_u32(406302727)][unconst_u32(841381000)])]; |
| let ptr36 = &vp3[39]; |
| } |
| } |
| let vf43: vec2f = saturate(vec2f(unconst_f32(0.3306e38), unconst_f32(0.2192e-8))); |
| vp3[unconst_u32(1483786031)] = modf(vec2h(unpack2x16snorm(unconst_u32(444259961)).xx)[0]); |
| var vf44: vec4f = atanh(vec4f(unconst_f32(-0.1492e25), unconst_f32(0.1585), unconst_f32(0.1675), unconst_f32(0.04152e-14))); |
| var vf45: vec2h = cosh(vec2h(unconst_f16(25555.5), unconst_f16(-27018.8))); |
| } |
| (*a0)[pack2x16snorm(vec2f(unconst_f32(0.5009), unconst_f32(0.01990)))] += vec4f(f32(vp3[unconst_u32(1667287508)].whole)); |
| for (var jj8=0u; jj8<3; jj8++) { (*a0)[jj8] *= vec4f(f32(vp3[vec4u((*a0)[0].araa.wywz).x].fract)); } |
| switch u32(round(unconst_f16(17389.1))) { |
| default { |
| (*a0)[unconst_u32(247517421)] += (*a0)[0]; |
| (*a0)[unconst_u32(507105840)] += bitcast<vec4f>( ~vec2i(unconst_i32(259282134), unconst_i32(344313092)).ggrg); |
| var vf46: bool = (unconst_bool(true) && unconst_bool(false)); |
| vp3[unconst_u32(2010501317)] = modf(distance(vec2h(unconst_f16(19114.6), unconst_f16(8944.1)), abs(vec4h(unconst_f16(2794.1), unconst_f16(6186.0), unconst_f16(18542.0), unconst_f16(12501.0))).ab)); |
| vp3[39].fract -= abs(vec4h(vp3[pack4x8unorm(vec4f(unconst_f32(-0.06925e21), unconst_f32(0.02477e-6), unconst_f32(0.07742), unconst_f32(0.04119e11)))].whole)).y; |
| break; |
| } |
| } |
| (*a0)[unconst_u32(3096414791)] = unpack4x8unorm(pack4xI8Clamp(vec4i(unconst_i32(164398061), unconst_i32(440389351), unconst_i32(147144341), unconst_i32(46108240)))); |
| var vf47: vec2f = atanh(vec2f(unconst_f32(0.06299e-42), unconst_f32(0.4720e15))); |
| let ptr37: ptr<workgroup, vec4f> = &(*a0)[0]; |
| vp3[unconst_u32(437749099)] = modf(vec3h(fract(vec3f(unconst_f32(0.1277), unconst_f32(0.00037e-24), unconst_f32(-0.1460e17))))[2]); |
| let vf48: vec3h = exp2(vec3h(unconst_f16(2480.9), unconst_f16(3645.9), unconst_f16(16222.2))); |
| var vf49: u32 = pack4xI8Clamp(vec4i(unconst_i32(34714678), unconst_i32(339929443), unconst_i32(52130143), unconst_i32(252859062))); |
| } |
| |
| struct T1 { |
| @size(6) f0: f32, |
| } |
| |
| var<workgroup> vw4: bool; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<workgroup> vw2: atomic<u32>; |
| |
| struct VertexInput17 { |
| @location(10) location_10: vec2i, |
| @location(14) location_14: f32, |
| @location(3) location_3: vec4u, |
| @location(2) location_2: vec2f, |
| @location(11) location_11: vec2f, |
| @location(1) location_1: i32, |
| @location(6) @interpolate(flat, center) location_6: i32, |
| } |
| |
| var<workgroup> vw3: vec2<bool>; |
| |
| struct VertexInput20 { |
| @location(7) location_7: f16, |
| } |
| |
| struct VertexOutput2 { |
| @location(0) location_0: vec4i, |
| @builtin(position) position: vec4f, |
| @location(14) location_14: vec2f, |
| @location(9) location_9: vec2u, |
| @location(7) @interpolate(flat, sample) location_7: vec2u, |
| @location(6) location_6: vec4u, |
| @location(11) location_11: vec2i, |
| @location(10) location_10: vec2u, |
| @location(8) location_8: vec4f, |
| @location(4) @interpolate(flat, sample) location_4: vec4i, |
| } |
| |
| struct VertexInput18 { |
| @location(4) location_4: vec4i, |
| @location(0) location_0: vec4i, |
| } |
| |
| @id(9920) override override5: f16 = 5642.7; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn1(a0: ptr<function, array<array<i32, 1>, 1>>) -> array<array<array<array<array<vec2h, 1>, 1>, 1>, 1>, 1> { |
| var out: array<array<array<array<array<vec2h, 1>, 1>, 1>, 1>, 1>; |
| let ptr38: ptr<function, array<vec2h, 1>> = &out[0][0][0][unconst_u32(963823566)]; |
| let ptr39: ptr<function, vec2h> = &out[unconst_u32(2212433687)][bitcast<u32>(out[unconst_u32(193483903)][unconst_u32(290451753)][unconst_u32(19569194)][unconst_u32(357563239)][0])][unconst_u32(1528230471)][0][unconst_u32(582167644)]; |
| { |
| let ptr40: ptr<function, array<array<vec2h, 1>, 1>> = &out[0][unconst_u32(133507546)][unconst_u32(167612150)]; |
| switch bitcast<i32>(out[0][0][unconst_u32(453005240)][0][unconst_u32(399153749)]) { |
| case 188442971, 864555992, 533393780 { |
| vp3[unconst_u32(248224565)] = modf(out[0][0][0][unconst_u32(2247297067)][0].x); |
| switch vec4u(atanh(vec4h(f16((*a0)[unconst_u32(507047169)][0]))))[2] { |
| default: { |
| out[unconst_u32(714569845)][unconst_u32(240843740)][0][unconst_u32(413900325)][unconst_u32(117456703)] += vec2h(reverseBits(vec4u(unconst_u32(219799953), unconst_u32(318641511), unconst_u32(21565193), unconst_u32(354758547))).wy); |
| } |
| } |
| if bool(out[unconst_u32(409022634)][0][unconst_u32(499142526)][0][unconst_u32(1148782275)][0]) { |
| out[unconst_u32(1208046470)][u32(vp3[unconst_u32(433878161)].whole)][0][unconst_u32(185974455)][unconst_u32(606328826)] += out[unconst_u32(1244634252)][unconst_u32(206493255)][unconst_u32(2467977609)][unconst_u32(489703073)][0]; |
| let ptr41: ptr<function, array<vec2h, 1>> = &out[0][unconst_u32(259293534)][0][unconst_u32(3211969451)]; |
| } |
| let ptr42: ptr<function, i32> = &(*a0)[unconst_u32(1884653700)][0]; |
| } |
| case default, 59661496: { |
| let ptr43: ptr<function, vec2h> = &out[0][u32(out[0][0][unconst_u32(415655018)][unconst_u32(249267795)][0][unconst_u32(489430113)])][unconst_u32(945401367)][0][0]; |
| out[unconst_u32(2064017116)][unconst_u32(288808960)][0][unconst_u32(963803156)][unconst_u32(150006367)] *= out[unconst_u32(746281413)][unconst_u32(1525972656)][unconst_u32(358026186)][0][unconst_u32(333413089)]; |
| let ptr44: ptr<function, vec2h> = &out[0][0][unconst_u32(1042260663)][0][0]; |
| } |
| } |
| vp3[unconst_u32(429661742)] = modf(override5); |
| (*a0)[unconst_u32(292368658)][unconst_u32(986400642)] = bitcast<i32>(out[unconst_u32(726700955)][0][0][unconst_u32(3258076546)][unconst_u32(12016541)]); |
| let vf50: f16 = out[unconst_u32(125541186)][unconst_u32(772676128)][unconst_u32(166819774)][unconst_u32(1271965786)][unconst_u32(1129966514)][unconst_u32(343208834)]; |
| return out; |
| _ = override5; |
| } |
| let ptr45: ptr<function, vec2h> = &out[unconst_u32(90112630)][unconst_u32(159763800)][0][0][0]; |
| for (var it4=u32(vp3[unconst_u32(265831154)].fract); it4<(bitcast<u32>(out[0][unconst_u32(976448130)][0][u32(out[0][0][0][unconst_u32(297404207)][unconst_u32(213958712)][unconst_u32(1010015974)])][0]) & 0xfff); it4++) { |
| (*a0)[bitcast<u32>(out[unconst_u32(1041110006)][unconst_u32(2762110160)][unconst_u32(1243493084)][unconst_u32(1026792857)][0])][unconst_u32(1021612283)] = bitcast<i32>(out[0][unconst_u32(1248247627)][bitcast<u32>(out[0][0][0][0][0])][0][0]); |
| } |
| let vf51: f16 = out[0][0][0][0][unconst_u32(1048714197)][unconst_u32(142890328)]; |
| for (var jj85=0u; jj85<3; jj85++) { out[jj85][unconst_u32(655036209)][unconst_u32(1238030552)][unconst_u32(1003899706)][0] -= out[bitcast<u32>(out[unconst_u32(255815025)][0][unconst_u32(410949761)][unconst_u32(158792838)][unconst_u32(2525380841)])][0][unconst_u32(346375427)][unconst_u32(803651416)][unconst_u32(63913341)]; } |
| vp3[unconst_u32(1638062624)].whole = out[0][unconst_u32(1090354576)][unconst_u32(74790258)][unconst_u32(64297424)][0][unconst_u32(96870534)]; |
| return out; |
| _ = override5; |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| var<private> vp3 = array(modf(f16(6105.1)), modf(f16(6758.0)), modf(f16(20163.6)), modf(f16(10918.1)), modf(f16(6720.4)), modf(f16(20571.7)), modf(f16(17902.7)), modf(f16(26681.6)), modf(f16(4289.0)), modf(f16(14638.2)), modf(f16(3189.5)), modf(f16(33772.2)), modf(f16(22874.2)), modf(f16(12699.8)), modf(f16(18991.0)), modf(f16(-3604.2)), modf(f16(4479.6)), modf(f16(13248.8)), modf(f16(7692.5)), modf(f16(5248.8)), modf(f16(12584.2)), modf(f16(-11748.9)), modf(f16(17541.3)), modf(f16(35894.9)), modf(f16(59.91)), modf(f16(14781.7)), modf(f16(407.3)), modf(f16(16816.6)), modf(f16(16881.8)), modf(f16(30584.9)), modf(f16(1056.4)), modf(f16(4142.6)), modf(f16(19975.1)), modf(f16(6245.0)), modf(f16(567.1)), modf(f16(21905.9)), modf(f16(13005.7)), modf(f16(22975.7)), modf(f16(955.5)), modf(f16(4761.8))); |
| |
| struct VertexInput19 { |
| @location(5) location_5: u32, |
| } |
| |
| /* zero global variables used */ |
| fn fn2(a0: ptr<workgroup, atomic<u32>>) { |
| let vf52: u32 = atomicLoad(&(*a0)); |
| atomicAdd(&(*a0), unconst_u32(543861733)); |
| } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw1: array<array<vec4f, 1>, 14>; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex3(a0: VertexInput17, a1: VertexInput18, a2: VertexInput19, a3: VertexInput20) -> VertexOutput2 { |
| var out: VertexOutput2; |
| let ptr46: ptr<private, f16> = &vp3[39].whole; |
| let vf53: i32 = insertBits(unconst_i32(856657941), unconst_i32(211455111), unconst_u32(198380872), unconst_u32(324704569)); |
| out.location_9 = vec2u(tan(vec2h(unconst_f16(18.72), unconst_f16(20304.4))).gr.rg); |
| var vf54: VertexInput17 = a0; |
| let vf55: i32 = a0.location_6; |
| var vf56: i32 = a0.location_1; |
| out.location_11 |= vec2i(i32(vp3[bitcast<u32>(acos(vec2h(unconst_f16(25072.3), unconst_f16(16791.8))))].fract)); |
| var vf57: vec2f = log2(vec2f(unconst_f32(0.2525e-2), unconst_f32(-0.02233))); |
| return out; |
| } |
| |
| /* used global variables: buffer58 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute6() { |
| vw1[unconst_u32(40807751)][unconst_u32(473710180)] *= vec4f(bitcast<f32>((*&buffer58)[arrayLength(&(*&buffer58))][13][unconst_u32(567799417)].location_6)); |
| let ptr47: ptr<storage, VertexInput17, read> = &(*&buffer58)[unconst_u32(544368719)][unconst_u32(590715266)][unconst_u32(328569523)]; |
| let ptr48: ptr<storage, vec2f, read> = &buffer58[unconst_u32(75522489)][unconst_u32(1907174087)][unconst_u32(521252854)].location_11; |
| let ptr49: ptr<storage, vec2i, read> = &(*ptr47).location_10; |
| _ = buffer58; |
| }`, |
| }); |
| let texture72 = device0.createTexture({ |
| size: [1, 270, 227], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer9, 4); |
| } catch {} |
| try { |
| renderPassEncoder2.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let textureView61 = texture14.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup21); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(3, 23, 5, 3_013_257_289); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 22, 0, 9_382_838, 1_375_235_163); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer46, 4); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let buffer59 = device0.createBuffer({ |
| label: '\ud855\u32ef\u02b3\u{1fd60}', |
| size: 403, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let textureView62 = texture3.createView({mipLevelCount: 1}); |
| let renderPassEncoder10 = commandEncoder56.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView43, |
| depthSlice: 63, |
| clearValue: { r: 218.6, g: 110.9, b: -922.5, a: -72.84, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder3.draw(4, 107, 1, 1_289_760_414); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 87, 0, 451_725_518, 242_608_490); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer38, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer18, 'uint16', 10, 13); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let sampler12 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| lodMaxClamp: 52.97, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup19, new Uint32Array(3379), 679, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(1, 381, 0, 331_559_724); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer6, 8); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(0, 180, 0, 763_669_723); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| buffer59.unmap(); |
| } catch {} |
| try { |
| computePassEncoder0.insertDebugMarker('\u27cd'); |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let renderBundle0 = renderBundleEncoder5.finish({}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer59, 32); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(5, 136, 4, 1_228_995_611); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer7, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.append(canvas1); |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| struct VertexOutput3 { |
| @location(8) @interpolate(perspective, either) location_8: vec2f, |
| @builtin(position) position: vec4f, |
| @location(2) @interpolate(perspective, either) location_2: vec4h, |
| @location(4) location_4: i32, |
| @location(9) location_9: vec2h, |
| @location(6) @interpolate(flat, either) location_6: vec4u, |
| @location(10) @interpolate(flat, first) location_10: vec4i, |
| } |
| |
| @id(21556) override override6 = 0.03631e-36; |
| |
| @group(1) @binding(529) var tex4: texture_3d<i32>; |
| |
| /* used global variables: buffer64, tex4 */ |
| fn fn0(a0: ptr<storage, array<array<u32, 1>, 90>, read>) { |
| _ = tex4; |
| vp4 = vec4u(vec4u(unconst_u32(2559613405), unconst_u32(115450726), unconst_u32(117186187), unconst_u32(719637325))); |
| let ptr50: ptr<storage, u32, read> = &(*a0)[unconst_u32(1628174268)][0]; |
| if bool((vec2u(dot4U8Packed(unconst_u32(125696283), unconst_u32(451361125))) & vec2u(unconst_u32(692094500), unconst_u32(736379347)))[0]) { |
| vp4 |= vec4u(unpack4x8snorm(unconst_u32(482392887)).wyxw.zyzy); |
| } |
| var vf58: vec3u = textureDimensions(tex4); |
| let ptr51: ptr<uniform, vec4i> = &buffer64.location_1; |
| vp5.fract += vec2h( !vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(true)).bg); |
| _ = tex4; |
| _ = buffer64; |
| } |
| |
| struct FragmentInput3 { |
| @location(3) location_3: i32, |
| @location(8) @interpolate(linear) location_8: vec4f, |
| } |
| |
| @group(1) @binding(4) var<storage, read_write> buffer63: array<array<vec2i, 52>>; |
| |
| var<private> vp5 = frexp(vec2h(3468.6, 11843.2)); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(3) @binding(56) var tex5: texture_2d<f32>; |
| |
| var<private> vp4: vec4u = vec4u(1107374701, 599571520, 273594583, 326661003); |
| |
| @group(0) @binding(191) var<uniform> buffer61: array<array<array<array<vec4i, 1>, 2>, 2>, 79>; |
| |
| @id(37605) override override8: bool; |
| |
| @id(43506) override override9: f32; |
| |
| @group(2) @binding(133) var<storage, read> buffer65: array<array<FragmentInput6, 7>, 32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentOutput1 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(3) @interpolate(flat, sample) location_3: vec2i, |
| @location(4) @interpolate(flat, sample) location_4: u32, |
| @location(0) location_0: vec2i, |
| } |
| |
| struct FragmentInput0 { |
| @location(5) @interpolate(flat, centroid) location_5: f32, |
| @location(4) location_4: vec4f, |
| @location(7) location_7: i32, |
| } |
| |
| /* used global variables: buffer61, buffer63, buffer65 */ |
| fn fn2(a0: array<array<array<vec2f, 1>, 1>, 2>, a1: array<array<array<vec4h, 5>, 1>, 1>) { |
| buffer63[unconst_u32(2532803136)][unconst_u32(968770617)] *= (*&buffer61)[78][1][1][0].wz; |
| let ptr57: ptr<uniform, vec4i> = &(*&buffer61)[unconst_u32(767359380)][1][pack4xI8(buffer61[unconst_u32(268979811)][1][vec2u(a0[pack4xI8(buffer61[78][unconst_u32(206078655)][unconst_u32(110450383)][unconst_u32(732387434)])][unconst_u32(536753104)][0].xy).r][0])][vec2u((*&buffer63)[arrayLength(&(*&buffer63))][51]).y]; |
| vp4 |= vec4u((*&buffer65)[31][unconst_u32(848598440)].location_9.grrr.grbb.zyzx); |
| { |
| let vf61: vec4h = a1[0][0][unconst_u32(1070506619)]; |
| vp4 -= unpack4xU8(bitcast<u32>(buffer61[78][1][1][unconst_u32(854756331)][unconst_u32(580475704)])); |
| buffer63[unconst_u32(750204394)][unconst_u32(277933091)] += buffer61[unconst_u32(117683923)][unconst_u32(646644001)][unconst_u32(177573860)][0].zz; |
| return; |
| _ = buffer63; |
| _ = buffer61; |
| } |
| _ = buffer61; |
| _ = buffer65; |
| _ = buffer63; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexInput22 { |
| @location(1) location_1: vec4u, |
| @location(13) location_13: u32, |
| @location(7) location_7: vec4h, |
| @location(0) location_0: vec4h, |
| } |
| |
| /* used global variables: buffer63, buffer64, tex5 */ |
| @must_use |
| fn fn3(a0: ptr<uniform, vec4i>, a1: ptr<uniform, vec4i>) -> array<array<array<vec2u, 7>, 1>, 1> { |
| var out: array<array<array<vec2u, 7>, 1>, 1>; |
| let vf62: f32 = abs(unconst_f32(0.3170e-23)); |
| let vf63: vec2u = textureDimensions(tex5); |
| out[unconst_u32(360917782)][unconst_u32(313004923)][unconst_u32(3229311256)] <<= vec2u(u32((*a1)[unconst_u32(19897267)])); |
| out[unconst_u32(349632611)][unconst_u32(2667696041)][unconst_u32(71602495)] |= bitcast<vec2u>(buffer64.location_1.ba.rg.gg); |
| buffer63[unconst_u32(184515449)][vp4[unconst_u32(481146495)]] = buffer63[unconst_u32(662883260)][unconst_u32(594431077)]; |
| for (var jj49=0u; jj49<54; jj49++) { buffer63[unconst_u32(76983422)][jj49] ^= vec2i(i32(arrayLength(&(*&buffer63)))); } |
| let ptr58: ptr<storage, array<vec2i, 52>, read_write> = &(*&buffer63)[unconst_u32(1853509256)]; |
| out[unconst_u32(1846031946)][unconst_u32(638116529)][out[0][0][6][1]] >>= vec2u((*&buffer63)[arrayLength(&(*&buffer63))][51].gr); |
| return out; |
| _ = tex5; |
| _ = buffer63; |
| _ = buffer64; |
| } |
| |
| override override7: f16 = -647.7; |
| |
| /* used global variables: buffer61, buffer63 */ |
| fn fn1(a0: vec4i) { |
| let ptr52: ptr<uniform, array<vec4i, 1>> = &(*&buffer61)[unconst_u32(657092590)][unconst_u32(88402615)][1]; |
| vp5 = frexp(vec2h((*&buffer63)[arrayLength(&(*&buffer63))][51].yx.rg.gg.rr.rr)); |
| var vf59: i32 = (*ptr52)[0][unconst_u32(391170869)]; |
| buffer63[vec4u(buffer61[unconst_u32(2279344335)][unconst_u32(451049334)][1][unconst_u32(162141373)].rraa).z][bitcast<u32>((*&buffer61)[78][unconst_u32(56932688)][1][0][3])] = vec2i(buffer61[unconst_u32(579978466)][1][unconst_u32(371365881)][0][unconst_u32(1067009348)]); |
| let ptr53: ptr<uniform, array<vec4i, 1>> = &buffer61[pack4xU8(vec4u(buffer61[78][unconst_u32(281353829)][1][unconst_u32(327876091)]))][u32(buffer61[78][1][unconst_u32(597756175)][unconst_u32(35483338)][unconst_u32(111376219)])][unconst_u32(374891497)]; |
| let ptr54: ptr<storage, array<array<vec2i, 52>>, read_write> = &(*&buffer63); |
| var vf60: i32 = buffer63[arrayLength(&buffer63)][unconst_u32(8643174)][unconst_u32(194468302)]; |
| let ptr55: ptr<uniform, vec4i> = &buffer61[78][1][unconst_u32(530550444)][0]; |
| let ptr56: ptr<storage, array<vec2i, 52>, read_write> = &(*&buffer63)[unconst_u32(319102948)]; |
| return; |
| _ = buffer61; |
| _ = buffer63; |
| } |
| |
| struct FragmentInput5 { |
| @location(15) location_15: vec4h, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(1) @binding(100) var<uniform> buffer64: FragmentInput1; |
| |
| @group(0) @binding(7) var<storage, read> buffer60: array<array<array<u32, 1>, 90>>; |
| |
| alias vec3b = vec3<bool>; |
| |
| struct FragmentInput4 { |
| @location(6) location_6: u32, |
| } |
| |
| struct T0 { |
| @size(8) f0: bool, |
| f1: array<vec4u, 1>, |
| @size(64) f2: array<array<array<vec4i, 2>, 1>, 1>, |
| } |
| |
| @group(1) @binding(1) var<storage, read_write> buffer62: array<array<array<array<array<array<f16, 1>, 1>, 64>, 1>, 4>>; |
| |
| struct T1 { |
| f0: array<u32>, |
| } |
| |
| struct FragmentInput2 { |
| @location(14) @interpolate(flat, first) location_14: u32, |
| @location(2) location_2: vec4f, |
| } |
| |
| struct FragmentInput1 { |
| @location(1) location_1: vec4i, |
| } |
| |
| struct FragmentInput6 { |
| @location(9) location_9: vec2h, |
| } |
| |
| struct VertexInput21 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| /* used global variables: buffer60, buffer61, buffer64, tex4 */ |
| @vertex |
| fn vertex4(a0: VertexInput21, a1: VertexInput22) -> VertexOutput3 { |
| var out: VertexOutput3; |
| out.location_4 = (*&buffer61)[unconst_u32(585748554)][unconst_u32(351694581)][1][unconst_u32(1842043605)].b; |
| out = VertexOutput3(vec2f(bitcast<f32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])), vec4f(bitcast<f32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])), vec4h(f16(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0])), bitcast<i32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]), bitcast<vec2h>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]), unpack4xU8(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]), vec4i(bitcast<i32>(buffer60[unconst_u32(661086511)][unconst_u32(156046772)][0]))); |
| out.location_8 = vec2f(buffer61[unconst_u32(21720692)][unconst_u32(1216766385)][1][0].ww); |
| out.location_10 += (*&buffer61)[unconst_u32(71424114)][unconst_u32(271860007)][unconst_u32(744411416)][0]; |
| fn0(&buffer60[arrayLength(&buffer60) - 1]); |
| out.location_2 = vec4h(buffer61[buffer60[arrayLength(&buffer60)][89][unconst_u32(208455537)]][1][unconst_u32(2086612483)][unconst_u32(401482150)]); |
| let vf64: mat3x4h = transpose(mat4x3h(unconst_f16(10122.3), unconst_f16(19236.1), unconst_f16(37673.1), unconst_f16(3413.0), unconst_f16(18937.4), unconst_f16(12792.5), unconst_f16(323.8), unconst_f16(31733.2), unconst_f16(5117.2), unconst_f16(5505.8), unconst_f16(21953.8), unconst_f16(14413.4))); |
| { |
| let ptr59: ptr<uniform, array<vec4i, 1>> = &(*&buffer61)[78][1][1]; |
| fn0(&(*&buffer60)[buffer61[unconst_u32(779649112)][unconst_u32(719879489)][1][0][0]]); |
| let ptr60: ptr<uniform, vec4i> = &(*&buffer61)[78][unconst_u32(23535237)][unconst_u32(493990147)][0]; |
| out.location_9 *= vec2h(buffer61[unconst_u32(575022502)][1][unconst_u32(32409783)][0].ar.rr.gg); |
| out.location_10 = bitcast<vec4i>(out.location_6.xwzz.yzzw.wwyx); |
| fn0(&(*&buffer60)[unconst_u32(115513722)]); |
| _ = buffer64; |
| _ = tex4; |
| _ = buffer60; |
| _ = buffer61; |
| } |
| return out; |
| _ = tex4; |
| _ = buffer61; |
| _ = buffer60; |
| _ = buffer64; |
| } |
| |
| /* used global variables: buffer62, buffer63, buffer64, tex5 */ |
| @fragment |
| fn fragment1(a0: FragmentInput0, @location(0) @interpolate(flat, first) location_0: vec2u, a2: FragmentInput1, a3: FragmentInput2, @builtin(sample_mask) sample_mask: u32, a5: FragmentInput3, a6: FragmentInput4, a7: FragmentInput5, a8: FragmentInput6) -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| if bool(buffer62[arrayLength(&buffer62)][3][0][63][0][0]) { |
| out = FragmentOutput1(u32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0]), vec2i(i32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0])), u32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0]), vec2i(i32((*&buffer62)[arrayLength(&(*&buffer62))][3][unconst_u32(509513955)][63][0][0]))); |
| _ = fn3(&buffer64.location_1, &buffer64.location_1); |
| if bool((*&buffer62)[unconst_u32(817402231)][unconst_u32(186143889)][unconst_u32(2348032439)][unconst_u32(461064918)][unconst_u32(513819711)][0]) { |
| buffer63[unconst_u32(1107044345)][unconst_u32(486273355)] -= vec2i(i32(buffer62[arrayLength(&buffer62)][location_0[unconst_u32(569181908)]][u32((*&buffer62)[unconst_u32(1772766578)][3][0][63][0][0])][unconst_u32(534467110)][unconst_u32(53559296)][unconst_u32(24067885)])); |
| _ = buffer62; |
| _ = buffer63; |
| } |
| _ = buffer62; |
| _ = buffer64; |
| _ = tex5; |
| _ = buffer63; |
| } |
| _ = fn3(&buffer64.location_1, &buffer64.location_1); |
| out.location_0 = vec2i(i32((*&buffer62)[arrayLength(&(*&buffer62))][unconst_u32(2125720084)][unconst_u32(1328261186)][63][unconst_u32(364727558)][0])); |
| let ptr61: ptr<storage, f16, read_write> = &buffer62[unconst_u32(1937642675)][3][0][63][0][0]; |
| var vf65 = fn3(&(*&buffer64).location_1, &(*&buffer64).location_1); |
| let ptr62: ptr<storage, f16, read_write> = &buffer62[unconst_u32(389617986)][unconst_u32(168975154)][0][unconst_u32(608704435)][unconst_u32(714712308)][0]; |
| let vf66: f32 = a0.location_5; |
| let ptr63: ptr<storage, f16, read_write> = &(*&buffer62)[unconst_u32(1695047200)][3][0][63][unconst_u32(1716267731)][unconst_u32(931439346)]; |
| vp5 = frexp(vec2h(buffer62[unconst_u32(540404659)][3][0][unconst_u32(443041094)][unconst_u32(1050836798)][0])); |
| return out; |
| _ = buffer64; |
| _ = buffer62; |
| _ = tex5; |
| _ = buffer63; |
| }`, |
| }); |
| try { |
| renderPassEncoder3.draw(1, 327, 1, 77_785_674); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 65, 0, 485_282_689, 1_460_077_025); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer6, 'uint16', 8, 20); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer38, 'uint32', 0, 1); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder(); |
| let textureView63 = texture9.createView({dimension: '1d'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer48, 16); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer46, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(7, buffer12, 148); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2496 */ |
| offset: 2496, |
| buffer: buffer7, |
| }, { |
| texture: texture14, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData7 = new ImageData(8, 8); |
| let bindGroup25 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer49}}, |
| {binding: 515, resource: sampler2}, |
| {binding: 100, resource: {buffer: buffer14, size: 88}}, |
| {binding: 1, resource: {buffer: buffer49, offset: 1024, size: 604}}, |
| {binding: 529, resource: textureView43}, |
| ], |
| }); |
| let buffer66 = device0.createBuffer({ |
| size: 124, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder80 = device0.createCommandEncoder(); |
| let texture73 = device0.createTexture({ |
| size: {width: 75}, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView64 = texture37.createView({}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 4, 0, -1_890_034_363, 188_406_115); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer39, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup14, new Uint32Array(3212), 631, 0); |
| } catch {} |
| let pipelineLayout5 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout1, recycledExplicitBindGroupLayout3, veryExplicitBindGroupLayout4], |
| }); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup24, new Uint32Array(607), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup15, new Uint32Array(80), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.draw(2, 257, 0, 146_666_590); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer59, 212); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(7, buffer20, 4, 0); |
| } catch {} |
| try { |
| commandEncoder71.copyTextureToTexture({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 23}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer67 = device0.createBuffer({size: 464, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let texture74 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(1, 338, 0, -1_878_480_840, 59_592_201); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer6, 28); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 4, new Uint32Array(9793).map((_, i) => i * 7), 1687, 0); |
| } catch {} |
| try { |
| globalThis.someLabel = commandEncoder2.label; |
| } catch {} |
| let buffer68 = device0.createBuffer({size: 280, usage: GPUBufferUsage.INDIRECT}); |
| let texture75 = device0.createTexture({size: [75, 1, 51], mipLevelCount: 2, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder22.setBindGroup(1, bindGroup21); |
| } catch {} |
| try { |
| computePassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.draw(2, 250, 0, 802_742_838); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer6, 24); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer20); |
| } catch {} |
| let buffer69 = device0.createBuffer({size: 308, usage: GPUBufferUsage.COPY_SRC}); |
| let commandEncoder82 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup24, []); |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup21, new Uint32Array(3718), 137, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer48, 4); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer18, 'uint32', 20, 1); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Float32Array(8907).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.5702)), 5240, 0); |
| } catch {} |
| let bindGroup26 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| let texture76 = device0.createTexture({ |
| size: [1, 540, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView65 = texture11.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder8.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(1, 206, 0, 1_052_041_101, 471_414_136); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer17, 32); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer27, 28, 16); |
| } catch {} |
| try { |
| buffer27.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(13); }; |
| } catch {} |
| await gc(); |
| let bindGroup27 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView16}, |
| {binding: 56, resource: textureView1}, |
| {binding: 591, resource: textureView38}, |
| ], |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup24, new Uint32Array(1596), 151, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.draw(2, 122, 0, 415_560_624); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.insertDebugMarker('\ub375'); |
| } catch {} |
| let bindGroup28 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []}); |
| let buffer70 = device0.createBuffer({size: 200, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let textureView66 = texture12.createView({mipLevelCount: 1, baseArrayLayer: 13, arrayLayerCount: 4}); |
| try { |
| renderPassEncoder1.draw(2, 202, 0, 1_771_435_196); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer49, 1_096); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer59, 236); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder8.copyBufferToBuffer(buffer50, 4, buffer13, 0, 12); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer71 = device0.createBuffer({ |
| size: 136, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder23.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup19, new Uint32Array(286), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.draw(2, 298, 0, 348_078_519); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(1, 69, 0, 955_674_122, 799_428_228); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer48, 20); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(3, buffer4, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 20, new Float16Array(7956).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.8646)), 2038, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 44, y: 1023 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(28); }; |
| } catch {} |
| await gc(); |
| let textureView67 = texture43.createView({baseArrayLayer: 0}); |
| let sampler13 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', lodMaxClamp: 93.91}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup21, new Uint32Array(6489), 225, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup24, new Uint32Array(2606), 1_024, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.draw(2, 109, 0, 153_638_795); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(1, 24, 0, 251_621_015, 1_357_785_106); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup21, new Uint32Array(1757), 138, 0); |
| } catch {} |
| let buffer72 = device0.createBuffer({size: 257, usage: GPUBufferUsage.COPY_DST}); |
| let commandBuffer2 = commandEncoder27.finish(); |
| let texture77 = device0.createTexture({ |
| size: [37, 1, 1], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(1236), 935, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup2, new Uint32Array(980), 299, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer71, 4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup0, []); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(1, buffer48, 0, 75); |
| } catch {} |
| try { |
| commandEncoder39.resolveQuerySet(querySet0, 2, 0, buffer12, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let texture78 = device0.createTexture({ |
| size: [90, 24, 231], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup24, new Uint32Array(274), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(1, 471, 0, 67_954_548, 1_940_742_059); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer46, 4); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer48, 68); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(2, buffer3, 28); |
| } catch {} |
| let commandBuffer3 = commandEncoder19.finish(); |
| let textureView68 = texture66.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer71, 16); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer19, 'uint16', 42, 6); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToTexture({ |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture45, |
| mipLevel: 1, |
| origin: {x: 0, y: 14, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder12.pushDebugGroup('\u0d87'); |
| } catch {} |
| try { |
| commandEncoder54.insertDebugMarker('\u0f9c'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let textureView69 = texture77.createView({aspect: 'all'}); |
| let renderPassEncoder11 = commandEncoder84.beginRenderPass({ |
| colorAttachments: [{view: textureView43, depthSlice: 31, loadOp: 'clear', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 8}, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup14, new Uint32Array(356), 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.draw(2, 40, 0, 131_691_143); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer49, 1_592); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 5264 */ |
| offset: 5264, |
| bytesPerRow: 16640, |
| buffer: buffer37, |
| }, { |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 0, y: 19, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame5 = new VideoFrame(canvas0, {timestamp: 0}); |
| let bindGroup30 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let texture79 = device0.createTexture({ |
| size: [37, 1, 6], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView70 = texture37.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder1.end(); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup3, []); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup15, new Uint32Array(1005), 52, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.draw(312, 137, 70, 405_401_975); |
| } catch {} |
| try { |
| commandEncoder77.copyBufferToBuffer(buffer33, 1876, buffer7, 152, 672); |
| } catch {} |
| let pipeline11 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4, constants: {}}}); |
| let texture80 = device0.createTexture({ |
| size: {width: 30, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView71 = texture74.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer20, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer43, 8, new Float32Array(26320).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.4924)), 1796, 4); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let pipeline12 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule2, constants: {}}}); |
| try { |
| adapter0.label = '\u9cc6\ubd5d\ub4d6\u07dc\u09a9'; |
| } catch {} |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let textureView72 = texture80.createView({}); |
| let textureView73 = texture48.createView({dimension: '3d'}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup21, new Uint32Array(109), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer19, 'uint32', 0, 6); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(3, buffer27, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer6, 'uint32', 8, 16); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(6, buffer39, 0, 17); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Float32Array(9596).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.530)), 2581, 0); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let bindGroup31 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let textureView74 = texture78.createView({dimension: '3d'}); |
| let textureView75 = texture71.createView({dimension: '3d', mipLevelCount: 1}); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup26, new Uint32Array(2003), 230, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer70, 'uint16', 4, 44); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer39, 12); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer18, 'uint32', 4, 2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(1, buffer7, 0); |
| } catch {} |
| try { |
| commandEncoder60.copyBufferToTexture({ |
| /* bytesInLastRow: 76 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1084 */ |
| offset: 1084, |
| bytesPerRow: 7168, |
| buffer: buffer7, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 19, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext2 = canvas2.getContext('webgpu'); |
| let texture81 = device0.createTexture({ |
| size: [1, 540, 1], |
| sampleCount: 4, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle1 = renderBundleEncoder0.finish({}); |
| try { |
| renderPassEncoder8.setVertexBuffer(4, buffer31, 28, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(5, buffer17); |
| } catch {} |
| let textureView76 = texture81.createView({}); |
| let textureView77 = texture5.createView({aspect: 'all', format: 'rgba16sint', arrayLayerCount: 1}); |
| let computePassEncoder24 = commandEncoder21.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline12); |
| } catch {} |
| let imageData8 = new ImageData(36, 148); |
| let bindGroup32 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: {buffer: buffer49}}]}); |
| let textureView78 = texture52.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer20); |
| } catch {} |
| let pipeline13 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x1582de47}, |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'constant'}, |
| alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'zero'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 80, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32', offset: 8, shaderLocation: 7}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 1}, |
| {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let imageData9 = new ImageData(52, 24); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 133, resource: {buffer: buffer49, offset: 0}}], |
| }); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let texture82 = device0.createTexture({ |
| size: {width: 7, height: 1, depthOrArrayLayers: 1}, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView79 = texture49.createView({format: 'rg32uint', baseArrayLayer: 15, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder5.drawIndexed(8, 67, 35, -1_934_032_568, 87_408_877); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer34, 'uint16', 0, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(12); }; |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'film', transfer: 'gamma22curve'} }); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer48, 'uint32', 8, 46); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup30, new Uint32Array(3793), 820, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Float16Array(2743).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.090)), 126, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let recycledExplicitBindGroupLayout5 = pipeline2.getBindGroupLayout(2); |
| try { |
| renderPassEncoder5.draw(0, 330, 0, 563_221_930); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(27, 72, 13, 443_611_004, 105_274_577); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer18, 'uint16', 18, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup31); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup6, new Uint32Array(2983), 126, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| label: '\u{1f7d4}\ub040\ufc7c\uc20f\u0723\uec7c\u1404\u{1fd10}\ubbd3', |
| layout: veryExplicitBindGroupLayout13, |
| entries: [{binding: 2, resource: {buffer: buffer49, size: 3420}}], |
| }); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let textureView80 = texture26.createView({label: '\u{1f748}\u70fe\u93d1\u084f\u6cd3\ud784\u0e89\u30fb', mipLevelCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup33, []); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(0, 2, 0, 381_591_728); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(7, buffer3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer12, 20); |
| } catch {} |
| try { |
| commandEncoder83.pushDebugGroup('\u015b'); |
| } catch {} |
| let imageData10 = new ImageData(48, 12); |
| let bindGroup35 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []}); |
| let texture83 = device0.createTexture({size: [150, 1, 1], mipLevelCount: 4, sampleCount: 1, format: 'rg8sint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView81 = texture61.createView({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup33); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup19, new Uint32Array(1033), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(0, 10, 0, 1_854_216_094); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(65, 27, 2, 494_638_579, 107_809_935); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer71, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer49, 'uint16', 260, 2_777); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder18.insertDebugMarker('\u{1ff55}'); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(66); }; |
| } catch {} |
| let texture84 = device0.createTexture({ |
| size: {width: 60}, |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup21, new Uint32Array(2586), 107, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer6, 32); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer67, 'uint32', 36, 38); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| let autogeneratedBindGroupLayout1 = pipeline11.getBindGroupLayout(0); |
| let bindGroup36 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder5.draw(0, 67, 0, 708_912_919); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(112, 38, 77, 1_521_623_631, 197_954_148); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer6, 12); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup18, new Uint32Array(784), 84, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer0, 0, 0); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToBuffer(buffer2, 0, buffer43, 0, 12); |
| } catch {} |
| try { |
| commandEncoder54.clearBuffer(buffer46, 0, 20); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let textureView82 = texture11.createView({mipLevelCount: 1}); |
| let renderPassEncoder12 = commandEncoder39.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView56, |
| clearValue: { r: -452.4, g: -726.3, b: -718.8, a: -959.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup33); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup29, new Uint32Array(1907), 90, 0); |
| } catch {} |
| try { |
| computePassEncoder24.dispatchWorkgroupsIndirect(buffer9, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(0, 13, 0, 1_512_392_146); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup31, new Uint32Array(658), 14, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer70, 'uint16', 26, 46); |
| } catch {} |
| try { |
| commandEncoder65.resolveQuerySet(querySet1, 19, 1, buffer26, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let textureView83 = texture81.createView({baseMipLevel: 0}); |
| let texture85 = device0.createTexture({ |
| size: {width: 1, height: 540, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup33); |
| } catch {} |
| try { |
| renderBundleEncoder12.popDebugGroup(); |
| } catch {} |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let texture86 = device0.createTexture({size: [90, 24, 1], sampleCount: 1, format: 'r8unorm', usage: GPUTextureUsage.COPY_SRC, viewFormats: []}); |
| let textureView84 = texture1.createView({}); |
| let renderPassEncoder13 = commandEncoder48.beginRenderPass({ |
| label: '\u88cb\u{1fe12}\u4194\u097e\u{1f82c}\u054c\uf627', |
| colorAttachments: [{ |
| view: textureView57, |
| clearValue: { r: 817.2, g: 764.6, b: -513.8, a: 538.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(179, 120, 246, 801_866_339, 932_873_608); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer48, 12); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup19, new Uint32Array(1068), 33, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 380, new Uint16Array(5041).map((_, i) => i + 4), 2237); |
| } catch {} |
| let computePassEncoder25 = commandEncoder51.beginComputePass(); |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 21, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline14 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| fragment: {module: shaderModule2, targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.GREEN}]}, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 80, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 12, shaderLocation: 11}, |
| {format: 'float32x2', offset: 16, shaderLocation: 7}, |
| {format: 'sint8x2', offset: 6, shaderLocation: 4}, |
| {format: 'sint32x4', offset: 48, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 2}, |
| {format: 'float16x4', offset: 16, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 4, |
| attributes: [ |
| {format: 'sint8x4', offset: 0, shaderLocation: 6}, |
| {format: 'uint32', offset: 0, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 64, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x4', offset: 20, shaderLocation: 0}, |
| {format: 'uint8x4', offset: 24, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer68, 32); }; |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(1225), 142, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer67, 'uint16', 28, 21); |
| } catch {} |
| try { |
| buffer71.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| await gc(); |
| let textureView85 = texture71.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup29, new Uint32Array(3009), 110, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer71, 0, 23); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer49, 'uint32', 1_452, 1_251); |
| } catch {} |
| try { |
| buffer50.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let texture87 = device0.createTexture({ |
| size: [1, 1080, 237], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture88 = device0.createTexture({ |
| size: [180, 48, 462], |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView86 = texture62.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup12, new Uint32Array(314), 5, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let renderPassEncoder14 = commandEncoder70.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 75.70, g: -932.5, b: 794.8, a: -832.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet2, endOfPassWriteIndex: 4}, |
| }); |
| let sampler14 = device0.createSampler({addressModeV: 'mirror-repeat', compare: 'greater-equal'}); |
| try { |
| renderPassEncoder2.setPipeline(pipeline14); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let texture89 = device0.createTexture({ |
| size: [7, 1, 1], |
| sampleCount: 4, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer39, 0); }; |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(4, buffer20, 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder13.insertDebugMarker('\u1473'); |
| } catch {} |
| let pipeline15 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0}}); |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'bt2020_10bit'} }); |
| let bindGroup37 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [{binding: 133, resource: {buffer: buffer49, offset: 1280}}], |
| }); |
| let texture90 = device0.createTexture({ |
| size: [1, 135, 1], |
| sampleCount: 4, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder15 = commandEncoder52.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView56, |
| clearValue: { r: -715.6, g: -55.17, b: 352.1, a: 559.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup33, new Uint32Array(10000), 3_365, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer71, 16, new DataView(new ArrayBuffer(65676)), 1134, 4); |
| } catch {} |
| let autogeneratedBindGroupLayout2 = pipeline11.getBindGroupLayout(0); |
| let textureView87 = texture90.createView({label: '\u3d45\u2320\u78b9\u5d9f\uf18e\u0764\u6ba7\u23ff'}); |
| let texture91 = device0.createTexture({ |
| size: [64, 64, 188], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8unorm'], |
| }); |
| let textureView88 = texture69.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer49, 1_076); }; |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(4, buffer31); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 2, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView89 = texture78.createView({dimension: '3d', arrayLayerCount: 1}); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], depthReadOnly: true}); |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline13); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 48 */ |
| offset: 48, |
| buffer: buffer40, |
| }, { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData11 = new ImageData(12, 4); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup24); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| buffer6.unmap(); |
| } catch {} |
| let imageData12 = new ImageData(24, 56); |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 8, resource: textureView18}, |
| {binding: 1, resource: textureView21}, |
| {binding: 591, resource: textureView9}, |
| {binding: 56, resource: textureView23}, |
| ], |
| }); |
| try { |
| renderBundleEncoder11.setPipeline(pipeline8); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(201); }; |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [{binding: 133, resource: {buffer: buffer49, size: 2080}}], |
| }); |
| let commandBuffer4 = commandEncoder45.finish(); |
| let texture92 = device0.createTexture({ |
| size: {width: 45, height: 12, depthOrArrayLayers: 14}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup21, new Uint32Array(5345), 867, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(9); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup9, new Uint32Array(1530), 344, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer49, 'uint32', 472, 1_940); |
| } catch {} |
| try { |
| buffer47.unmap(); |
| } catch {} |
| try { |
| commandEncoder77.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 460 */ |
| offset: 460, |
| bytesPerRow: 9472, |
| buffer: buffer33, |
| }, { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'logSqrt'} }); |
| let texture93 = device0.createTexture({ |
| size: [1, 135, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup30, new Uint32Array(134), 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer41, 84, new Float32Array(6255).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.819)), 612, 8); |
| } catch {} |
| let imageData13 = new ImageData(16, 32); |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [{binding: 133, resource: {buffer: buffer49, size: 1232}}], |
| }); |
| let texture94 = device0.createTexture({ |
| size: [1], |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture95 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup29, new Uint32Array(769), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup12, new Uint32Array(2197), 487, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.drawIndexedIndirect(buffer59, 8); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer6, 'uint32', 12, 10); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline7); |
| } catch {} |
| let textureView90 = texture66.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setBlendConstant({ r: 463.7, g: 995.7, b: -186.4, a: 383.7, }); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.drawIndirect(buffer39, 4); |
| } catch {} |
| try { |
| renderPassEncoder10.insertDebugMarker('\u88dd'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 16, new Uint32Array(7644).map((_, i) => i * 6), 1939, 4); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(33); }; |
| } catch {} |
| try { |
| renderPassEncoder10.label = '\u59fd\u0d08\u00cc\u300a\u0ad2\u0dbc\u{1fd4f}\u21c0\u{1f842}\u0f22'; |
| } catch {} |
| let recycledExplicitBindGroupLayout6 = pipeline15.getBindGroupLayout(1); |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let textureView91 = texture51.createView({}); |
| try { |
| computePassEncoder3.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer20, 'uint32', 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer12, 8); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup36, new Uint32Array(1431), 216, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.drawIndirect(buffer6, 0); |
| } catch {} |
| let textureView92 = texture48.createView({}); |
| let renderBundle2 = renderBundleEncoder4.finish({}); |
| let sampler15 = device0.createSampler({addressModeU: 'repeat', minFilter: 'nearest'}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer12, 0, 31); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(768), 5, 0); |
| } catch {} |
| let recycledExplicitBindGroupLayout7 = pipeline1.getBindGroupLayout(0); |
| let textureView93 = texture82.createView({}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup24, new Uint32Array(265), 88, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer71, 8); }; |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup12, new Uint32Array(4858), 1_563, 0); |
| } catch {} |
| try { |
| commandEncoder91.copyTextureToTexture({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 4}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\u857c\u044a\ub088\u2256\ubb9f\ufc88\u755c\u74b5\u{1fff6}\ubd36\u843a'; |
| } catch {} |
| let buffer73 = device0.createBuffer({size: 264, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup29, new Uint32Array(1374), 461, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 3014 */ |
| offset: 3014, |
| bytesPerRow: 16896, |
| buffer: buffer33, |
| }, { |
| texture: texture85, |
| mipLevel: 1, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 26, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 24, new Float16Array(1804).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.9136)), 36, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup24, new Uint32Array(3136), 444, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(3, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer4, 0, 29); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 8, new Uint32Array(8264).map((_, i) => i * 2), 3374, 0); |
| } catch {} |
| let imageData14 = new ImageData(12, 20); |
| let buffer74 = device0.createBuffer({size: 56, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let texture96 = device0.createTexture({size: {width: 15}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let textureView94 = texture85.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer59, 56); }; |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer6, 'uint16', 34, 48); |
| } catch {} |
| let bindGroup41 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout6, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup26, new Uint32Array(2808), 248, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer31, 0, 15); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte432', transfer: 'unspecified'} }); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer70, 'uint16', 12, 13); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer12, 132, 43); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| await gc(); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true}); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer39, 0, 7); |
| } catch {} |
| let imageData15 = new ImageData(56, 72); |
| let textureView95 = texture77.createView({}); |
| let textureView96 = texture33.createView({format: 'r8unorm', baseMipLevel: 0}); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer71, 'uint32', 56, 3); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer20, 'uint16', 0, 0); |
| } catch {} |
| try { |
| commandEncoder54.copyBufferToBuffer(buffer40, 100, buffer44, 8, 24); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let texture97 = device0.createTexture({ |
| size: [75, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler16 = device0.createSampler({ |
| label: '\ua044\ua800\u{1fd07}\u0425\u013b\ud10b\u0d08\uf2ad', |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 63.04, |
| }); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer20, 'uint16', 0, 2); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer75 = device0.createBuffer({size: 76, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let texture98 = device0.createTexture({ |
| size: {width: 1, height: 135, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder16 = commandEncoder36.beginRenderPass({ |
| colorAttachments: [{view: textureView43, depthSlice: 12, loadOp: 'load', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 4294967295}, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup35, new Uint32Array(110), 38, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(5, buffer38, 0, 7); |
| } catch {} |
| try { |
| computePassEncoder7.insertDebugMarker('\u{1faff}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 8_956, new Uint32Array(37132).map((_, i) => i * 8), 271, 700); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise15; |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 100, resource: {buffer: buffer32, offset: 4608}}, |
| {binding: 515, resource: sampler2}, |
| {binding: 529, resource: textureView67}, |
| {binding: 1, resource: {buffer: buffer49}}, |
| {binding: 4, resource: {buffer: buffer49, offset: 3072}}, |
| ], |
| }); |
| let buffer76 = device0.createBuffer({ |
| size: 132, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture99 = device0.createTexture({ |
| size: {width: 37, height: 1, depthOrArrayLayers: 15}, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer71, 20); }; |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| enable f16; |
| |
| @group(1) @binding(1) var<storage, read_write> buffer78: array<array<f16, 256>>; |
| |
| struct FragmentInput8 { |
| @location(9) location_9: vec2h, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentInput10 { |
| @location(8) @interpolate(linear) location_8: vec4f, |
| @location(2) location_2: vec4f, |
| } |
| |
| struct T0 { |
| f0: vec2u, |
| @size(80) f1: array<vec4i, 1>, |
| } |
| |
| struct VertexInput25 { |
| @location(13) @interpolate(perspective, sample) location_13: f32, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @id(16895) override override11: f16; |
| |
| var<workgroup> vw5: array<array<atomic<u32>, 1>, 1>; |
| |
| @group(0) @binding(191) var<uniform> buffer77: array<array<vec4f, 316>, 1>; |
| |
| var<workgroup> vw6: vec4u; |
| |
| struct FragmentInput7 { |
| @location(6) location_6: u32, |
| @location(4) location_4: vec4f, |
| @location(1) location_1: vec4i, |
| @location(14) @interpolate(flat, first) location_14: u32, |
| @location(5) @interpolate(flat, centroid) location_5: f32, |
| } |
| |
| @id(42604) override override10: i32; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<private> vp8: array<array<vec2<bool>, 12>, 1> = array(array(vec2<bool>(true, false), vec2<bool>(true, true), vec2<bool>(false, false), vec2<bool>(false, false), vec2<bool>(false, false), vec2<bool>(false, true), vec2<bool>(false, false), vec2<bool>(false, false), vec2<bool>(true, true), vec2<bool>(true, false), vec2<bool>(false, false), vec2<bool>(true, true))); |
| |
| var<private> vp7 = frexp(vec2h(15539.4, 41930.1)); |
| |
| struct T2 { |
| f0: array<atomic<u32>>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(3) @binding(1) var st4: texture_storage_1d<rgba16sint, read>; |
| |
| struct VertexInput24 { |
| @location(15) @interpolate(flat, sample) location_15: i32, |
| } |
| |
| struct T1 { |
| f0: array<atomic<u32>>, |
| } |
| |
| @group(1) @binding(100) var<uniform> buffer80: array<array<vec4f, 1>, 5>; |
| |
| struct FragmentInput11 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| struct FragmentInput9 { |
| @location(7) location_7: i32, |
| @location(13) location_13: vec2i, |
| } |
| |
| var<private> vp6: bool = bool(true); |
| |
| @group(1) @binding(4) var<storage, read_write> buffer79: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 52>, 1>, 4>>; |
| |
| @id(36733) override override12: u32 = (1936358811 % 103) + 1; |
| |
| struct VertexInput26 { |
| @location(5) @interpolate(linear, centroid) location_5: vec2f, |
| @location(8) location_8: vec2u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput23 { |
| @location(7) @interpolate(linear, either) location_7: vec2f, |
| } |
| |
| /* used global variables: buffer77, buffer80, st4 */ |
| @vertex |
| fn vertex5(@location(3) location_3: f16, @location(0) @interpolate(flat) location_0: vec2u, a2: VertexInput23, @location(11) location_11: f16, @location(12) @interpolate(flat, first) location_12: vec2f, a5: VertexInput24, a6: VertexInput25, @location(2) @interpolate(flat, centroid) location_2: vec4u, a8: VertexInput26) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out -= (*&buffer77)[0][315]; |
| let vf67: vec2h = fract(vec2h(unconst_f16(35360.1), unconst_f16(9527.3))); |
| if bool(buffer80[4][unconst_u32(3529135059)].b) { |
| var vf68: vec4u = location_2; |
| return out; |
| } |
| _ = st4; |
| let ptr64: ptr<uniform, vec4f> = &buffer77[0][315]; |
| let ptr65: ptr<uniform, array<vec4f, 1>> = &(*&buffer80)[4]; |
| out += vec4f(f32((unconst_f32(0.3829e26) > unconst_f32(0.00007)))); |
| return out; |
| _ = st4; |
| _ = buffer77; |
| _ = buffer80; |
| } |
| |
| /* used global variables: buffer78, buffer79, buffer80 */ |
| @fragment |
| fn fragment2(a0: FragmentInput7, @location(10) location_10: vec2f, @location(3) @interpolate(flat, sample) location_3: i32, a3: FragmentInput8, @location(0) @interpolate(flat, either) location_0: vec2u, a5: FragmentInput9, @location(15) location_15: vec4h, a7: FragmentInput10, @builtin(sample_mask) sample_mask: u32, @invariant @builtin(position) position: vec4f, a10: FragmentInput11, @builtin(sample_index) sample_index: u32) -> @location(200) vec4f { |
| var out: vec4f; |
| let ptr66: ptr<storage, array<f16, 1>, read_write> = &buffer79[unconst_u32(1401607488)][3][0][u32((*&buffer79)[arrayLength(&(*&buffer79))][unconst_u32(477573248)][0][51][0][unconst_u32(158709707)][0])][0][unconst_u32(1081690533)]; |
| buffer78[unconst_u32(401278747)][unconst_u32(2424642930)] -= (*&buffer79)[unconst_u32(3235549058)][3][unconst_u32(36741050)][51][0][0][0]; |
| for (var it5=u32((*&buffer79)[unconst_u32(597840063)][unconst_u32(1190417353)][0][unconst_u32(579946176)][0][0][unconst_u32(1527435863)]); it5<(u32(buffer79[unconst_u32(1770302205)][arrayLength(&(*&buffer78))][0][unconst_u32(1180196227)][0][unconst_u32(151934503)][0]) & 0xfff); it5++) { |
| var vf69: f32 = (*&buffer80)[4][0][unconst_u32(513138840)]; |
| let ptr67: ptr<storage, f16, read_write> = &(*&buffer79)[u32(buffer79[arrayLength(&buffer79)][3][unconst_u32(307532853)][51][unconst_u32(54954164)][0][0])][3][0][unconst_u32(214659045)][unconst_u32(768553593)][unconst_u32(180688569)][0]; |
| let vf70: vec2f = atanh(vec2f(unconst_f32(0.02011e1), unconst_f32(-0.2779))); |
| return out; |
| _ = buffer80; |
| _ = buffer79; |
| } |
| vp6 = bool(buffer79[arrayLength(&buffer79)][unconst_u32(3191164305)][u32(buffer79[arrayLength(&buffer79)][unconst_u32(37247804)][unconst_u32(70928389)][unconst_u32(203418474)][unconst_u32(1638219036)][unconst_u32(27342978)][0])][unconst_u32(868289371)][0][0][unconst_u32(322929919)]); |
| let ptr68: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer79[unconst_u32(722821544)][3][u32((*&buffer79)[arrayLength(&(*&buffer79))][unconst_u32(169062246)][unconst_u32(901168755)][unconst_u32(159537011)][unconst_u32(949281660)][0][0])][unconst_u32(1922709601)][unconst_u32(297084137)]; |
| let ptr69: ptr<storage, f16, read_write> = &(*&buffer79)[unconst_u32(1115083801)][3][u32((*&buffer79)[unconst_u32(219072351)][unconst_u32(42210577)][unconst_u32(545876243)][unconst_u32(611274038)][0][0][0])][51][0][0][unconst_u32(746776033)]; |
| out = vec4f(f32(buffer79[arrayLength(&buffer79)][3][unconst_u32(777735808)][51][unconst_u32(2472865801)][0][unconst_u32(287907532)])); |
| vp6 = bool(buffer79[unconst_u32(540150500)][3][0][51][0][unconst_u32(937281134)][unconst_u32(1169680890)]); |
| vp6 = bool(buffer79[arrayLength(&buffer79)][unconst_u32(227087345)][unconst_u32(189092231)][51][unconst_u32(570676615)][unconst_u32(316074599)][unconst_u32(565063237)]); |
| return out; |
| _ = buffer78; |
| _ = buffer79; |
| _ = buffer80; |
| }`, |
| }); |
| let buffer82 = device0.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let texture100 = device0.createTexture({ |
| size: {width: 7, height: 1, depthOrArrayLayers: 5}, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture101 = device0.createTexture({ |
| size: {width: 45, height: 12, depthOrArrayLayers: 47}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView97 = texture3.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup23, new Uint32Array(399), 3, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let textureView98 = texture100.createView({}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup41, new Uint32Array(1662), 11, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroupsIndirect(buffer82, 8); }; |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(4, buffer39); |
| } catch {} |
| try { |
| commandEncoder83.popDebugGroup(); |
| } catch {} |
| let pipeline16 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}}); |
| let imageBitmap0 = await createImageBitmap(imageData2); |
| let imageData16 = new ImageData(20, 36); |
| let recycledExplicitBindGroupLayout8 = pipeline14.getBindGroupLayout(0); |
| let buffer83 = device0.createBuffer({size: 10714, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let texture102 = device0.createTexture({size: [64, 64, 20], dimension: '3d', format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer9, 0); }; |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(5, 4, 13, 261_948_441); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer71, 20, new DataView(new ArrayBuffer(33700)), 3592, 12); |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder15.beginOcclusionQuery(7); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer70, 'uint32', 36, 3); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer48, 0, 27); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(8, 47, 19, 337_274_437); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexed(6, 252, 8, 315_833_208, 578_204_996); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline8); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 32, new DataView(new Uint8Array(2504).map((_, i) => i).buffer), 526, 8); |
| } catch {} |
| let pipeline17 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x3f8474c4}, |
| fragment: {module: shaderModule2, constants: {}, targets: [{format: 'bgra8unorm'}]}, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x2', offset: 0, shaderLocation: 2}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 5}, |
| {format: 'uint32', offset: 0, shaderLocation: 14}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 7}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 13}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 10}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 1}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 12}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 15}, |
| {format: 'float32', offset: 0, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 4}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 6}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 8}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', unclippedDepth: true}, |
| }); |
| try { |
| await promise18; |
| } catch {} |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer4, 16, 21); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(20, 224, 9, 219_378_376); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer6, 8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 15, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 2, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup26, new Uint32Array(1770), 302, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer68, 64); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndirect(buffer82, 52); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer42, 0, new Uint32Array(2516).map((_, i) => i * 6), 157, 4); |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| let texture103 = device0.createTexture({ |
| size: [1], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer73, 0); }; |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(14, 45, 0, 262_286_663); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer66, 'uint32', 4, 32); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToBuffer(buffer2, 4, buffer72, 16, 8); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 133, resource: {buffer: buffer49, offset: 768}}], |
| }); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let textureView99 = texture90.createView({aspect: 'stencil-only'}); |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup19, new Uint32Array(673), 160, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup31, new Uint32Array(2120), 1_254, 0); |
| } catch {} |
| try { |
| commandEncoder40.resolveQuerySet(querySet0, 1, 0, buffer0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 128, new Uint32Array(1035).map((_, i) => i * 3), 166, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer42, 0, new Uint32Array(32681).map((_, i) => i * 6), 8171, 0); |
| } catch {} |
| let commandBuffer5 = commandEncoder9.finish(); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup21, new Uint32Array(261), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(16, 269, 0, 3_351_771_757); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexed(101, 106, 31, 52_202_308, 470_140_391); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer34, 'uint16', 0, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'jedecP22Phosphors', transfer: 'iec6196624'} }); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let texture104 = device0.createTexture({ |
| size: [90, 24, 231], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder24.end(); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let buffer84 = device0.createBuffer({size: 4144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let sampler17 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', minFilter: 'linear'}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder23.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup40, new Uint32Array(1791), 984, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer66, 'uint16', 2, 2); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup33, new Uint32Array(1129), 241, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer74, 4); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder74.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 1, |
| origin: {x: 0, y: 51, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture105 = device0.createTexture({ |
| size: [1], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture106 = device0.createTexture({ |
| size: [180, 48, 24], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup41, new Uint32Array(1017), 110, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(4, buffer31, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexed(26, 15, 4, 947_590_563, 11); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer18, 'uint16', 24, 34); |
| } catch {} |
| try { |
| commandEncoder71.resolveQuerySet(querySet0, 0, 0, buffer3, 0); |
| } catch {} |
| let texture107 = device0.createTexture({ |
| size: [18], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup31, new Uint32Array(388), 130, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: textureView39}, |
| {binding: 8, resource: textureView18}, |
| {binding: 591, resource: textureView53}, |
| {binding: 56, resource: textureView1}, |
| ], |
| }); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| let textureView100 = texture107.createView({}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup21, new Uint32Array(1744), 359, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup18, new Uint32Array(3034), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(5, buffer31, 0, 9); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 76, new Uint32Array(3711).map((_, i) => i * 1), 865, 4); |
| } catch {} |
| let commandBuffer6 = commandEncoder69.finish(); |
| let textureView101 = texture80.createView({}); |
| let textureView102 = texture68.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let renderBundle3 = renderBundleEncoder7.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder13.draw(0, 98, 0, 162_580_549); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer67, 'uint16', 14, 10); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(imageData14); |
| let buffer85 = device0.createBuffer({size: 220, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let texture108 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView103 = texture32.createView({}); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup39, new Uint32Array(315), 88, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer66, 'uint16', 2, 15); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer48, 96); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(13); }; |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} }); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let textureView104 = texture59.createView({}); |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer38, 'uint16', 4, 1); |
| } catch {} |
| try { |
| commandEncoder105.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 8, resource: textureView7}, |
| {binding: 56, resource: textureView23}, |
| {binding: 591, resource: textureView9}, |
| {binding: 1, resource: textureView84}, |
| ], |
| }); |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let texture109 = device0.createTexture({ |
| size: [60, 1, 192], |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup31, new Uint32Array(11), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(4, buffer48, 28); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({label: '\u0601\u9ef9\u{1f96c}\u01b1\u4ad4\uba83'}); |
| let textureView105 = texture50.createView({mipLevelCount: 1}); |
| let renderBundle4 = renderBundleEncoder13.finish(); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup21, new Uint32Array(2224), 948, 0); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let textureView106 = texture52.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 20, new DataView(new ArrayBuffer(167520)), 1499, 0); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup46 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let texture110 = device0.createTexture({ |
| size: {width: 37, height: 1, depthOrArrayLayers: 41}, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture111 = device0.createTexture({ |
| size: [7], |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer19, 'uint32', 8, 24); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 270, depthOrArrayLayers: 264} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 41, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 0, y: 66, z: 97}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 75, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let textureView107 = texture110.createView({}); |
| let texture112 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView108 = texture61.createView({baseArrayLayer: 0}); |
| let renderPassEncoder17 = commandEncoder44.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: -719.3, g: -345.1, b: 243.1, a: 431.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder8.beginOcclusionQuery(8); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup40, new Uint32Array(5126), 2_348, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer6]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer71, 0, new DataView(new ArrayBuffer(6648)), 479, 24); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder8.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup18); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(20); }; |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(canvas0); |
| let commandBuffer7 = commandEncoder15.finish(); |
| let bindGroup47 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [{binding: 133, resource: {buffer: buffer84, size: 1264}}], |
| }); |
| let buffer86 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let textureView109 = texture67.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup35, new Uint32Array(1797), 21, 0); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline9); |
| } catch {} |
| try { |
| commandEncoder108.copyBufferToTexture({ |
| /* bytesInLastRow: 128 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 192 */ |
| offset: 192, |
| rowsPerImage: 670, |
| buffer: buffer37, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer87 = device0.createBuffer({ |
| label: '\u0997\u98c2\u38b0\u{1f89f}\u{1f997}\ua383\u3a00', |
| size: 124, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| }); |
| let textureView110 = texture111.createView({aspect: 'all'}); |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 65.47, |
| compare: 'always', |
| maxAnisotropy: 10, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer6, 12); }; |
| } catch {} |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup32, new Uint32Array(2439), 67, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer7, 2_560); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer74, 4, new DataView(new ArrayBuffer(10856)), 4666, 0); |
| } catch {} |
| let pipeline18 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'bgra8unorm', writeMask: 0}], |
| }, |
| vertex: { |
| module: shaderModule5, |
| entryPoint: 'vertex4', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x2', offset: 652, shaderLocation: 1}, |
| {format: 'uint32x4', offset: 584, shaderLocation: 13}, |
| {format: 'unorm16x4', offset: 68, shaderLocation: 7}, |
| {format: 'float32x4', offset: 1656, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: false}, |
| }); |
| let texture113 = device0.createTexture({ |
| size: {width: 180, height: 48, depthOrArrayLayers: 462}, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup19, new Uint32Array(2879), 402, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer59, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer49, 'uint32', 328, 58); |
| } catch {} |
| try { |
| commandEncoder81.copyBufferToTexture({ |
| /* bytesInLastRow: 168 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1736 */ |
| offset: 1736, |
| bytesPerRow: 9216, |
| buffer: buffer33, |
| }, { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout6, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let texture114 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 18}, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView111 = texture110.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| let buffer88 = device0.createBuffer({size: 112, usage: GPUBufferUsage.COPY_DST}); |
| let texture115 = device0.createTexture({ |
| size: {width: 15}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup48, []); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(5, buffer3); |
| } catch {} |
| try { |
| commandEncoder49.copyBufferToBuffer(buffer20, 0, buffer44, 28, 4); |
| } catch {} |
| try { |
| commandEncoder85.copyTextureToBuffer({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 4024 */ |
| offset: 4024, |
| bytesPerRow: 28160, |
| rowsPerImage: 165, |
| buffer: buffer84, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(13, 402); |
| let commandEncoder112 = device0.createCommandEncoder(); |
| let commandBuffer8 = commandEncoder21.finish(); |
| let textureView112 = texture115.createView({}); |
| let computePassEncoder26 = commandEncoder66.beginComputePass(); |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer67, 'uint16', 70, 52); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(4, buffer76); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer20, 'uint16', 2, 1); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| computePassEncoder21.end(); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 20, new Uint32Array(5075).map((_, i) => i * 9), 428, 8); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(46); }; |
| } catch {} |
| let recycledExplicitBindGroupLayout9 = pipeline9.getBindGroupLayout(2); |
| let buffer89 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder114 = device0.createCommandEncoder({label: '\uad3f\u{1fa62}\u{1fb53}\u58e7\ue80c'}); |
| let textureView113 = texture115.createView({dimension: '1d', baseMipLevel: 0}); |
| let texture116 = gpuCanvasContext1.getCurrentTexture(); |
| let renderPassEncoder18 = commandEncoder79.beginRenderPass({colorAttachments: [{view: textureView75, depthSlice: 745, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer74, 4); }; |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, buffer39, 0, 21); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(117); }; |
| } catch {} |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte170m', transfer: 'bt709'} }); |
| let texture117 = device0.createTexture({ |
| size: {width: 75, height: 1, depthOrArrayLayers: 410}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer71, 8); }; |
| } catch {} |
| try { |
| commandEncoder58.resolveQuerySet(querySet2, 0, 0, buffer34, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 32, height: 32, depthOrArrayLayers: 94} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture91, |
| mipLevel: 1, |
| origin: {x: 4, y: 6, z: 27}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer90 = device0.createBuffer({size: 268, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let texture118 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 18}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView114 = texture94.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer9, 12); }; |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup48); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer71, 'uint16', 20, 12); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(1, buffer7, 0, 1_207); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let texture119 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView115 = texture25.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderBundleEncoder14.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer42, 0, new Float16Array(1758).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.7611)), 194, 4); |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let textureView116 = texture119.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer34, 'uint16', 0, 0); |
| } catch {} |
| try { |
| buffer68.unmap(); |
| } catch {} |
| let commandBuffer9 = commandEncoder20.finish(); |
| let texture120 = device0.createTexture({ |
| size: {width: 60, height: 1, depthOrArrayLayers: 12}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture121 = device0.createTexture({ |
| size: {width: 7, height: 1, depthOrArrayLayers: 37}, |
| sampleCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer85, 4); }; |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(3, bindGroup34, new Uint32Array(5230), 744, 0); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToBuffer({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 296 widthInBlocks: 74 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5032 */ |
| offset: 5032, |
| buffer: buffer7, |
| }, {width: 74, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer89, 8, new BigInt64Array(10304).map((_, i) => BigInt(i - 1)), 382, 0); |
| } catch {} |
| await gc(); |
| let bindGroup50 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 56, resource: textureView33}, |
| {binding: 1, resource: textureView16}, |
| {binding: 591, resource: textureView106}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let texture122 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture123 = device0.createTexture({ |
| size: [60, 1, 1], |
| mipLevelCount: 3, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView117 = texture28.createView({}); |
| let computePassEncoder27 = commandEncoder117.beginComputePass(); |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline13); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9, commandBuffer7]); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| document.body.append(canvas2); |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let textureView118 = texture117.createView({arrayLayerCount: 1}); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], depthReadOnly: true}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup44, new Uint32Array(1123), 40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder104.resolveQuerySet(querySet4, 168, 7, buffer25, 0); |
| } catch {} |
| try { |
| await promise19; |
| } catch {} |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer71, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(0, buffer3, 24, 5); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup48, new Uint32Array(1716), 71, 0); |
| } catch {} |
| try { |
| commandEncoder93.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 34, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 4, new DataView(new ArrayBuffer(52744)), 1450, 8); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let buffer91 = device0.createBuffer({size: 400, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let texture124 = device0.createTexture({ |
| size: {width: 22, height: 6, depthOrArrayLayers: 57}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView119 = texture123.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(0, buffer31, 0, 11); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup49, new Uint32Array(3278), 925, 0); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder8.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer4); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer48, 'uint16', 80, 8); |
| } catch {} |
| let pipeline19 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| fragment: {module: shaderModule2, targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA}]}, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x4', offset: 0, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'float16x4', offset: 0, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 11}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 3}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 5}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 1}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 6}, |
| {format: 'float32', offset: 0, shaderLocation: 2}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let autogeneratedBindGroupLayout3 = pipeline6.getBindGroupLayout(0); |
| let buffer92 = device0.createBuffer({size: 252, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, mappedAtCreation: false}); |
| let textureView120 = texture35.createView({}); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup32, new Uint32Array(263), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder16.setBlendConstant({ r: 265.2, g: 949.3, b: 284.0, a: -95.76, }); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer38, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(1, buffer86); |
| } catch {} |
| try { |
| adapter0.label = '\u5d62\u{1f8dc}\uec52\u0bf9\u{1fbe0}\u70b0\u09eb\u{1f690}\u{1fafc}\u{1fa98}'; |
| } catch {} |
| let texture125 = device0.createTexture({ |
| size: {width: 75, height: 1, depthOrArrayLayers: 1}, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let texture126 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView121 = texture84.createView({aspect: 'all'}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder22.end(); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup29, new Uint32Array(592), 35, 0); |
| } catch {} |
| try { |
| commandEncoder7.insertDebugMarker('\u8cc8'); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(40); }; |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let buffer93 = device0.createBuffer({ |
| size: 34, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup31, new Uint32Array(968), 555, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 6}, |
| aspect: 'all', |
| }, new Uint8Array(138_888).fill(213), /* required buffer size: 138_888 */ |
| {offset: 48, bytesPerRow: 89, rowsPerImage: 130}, {width: 8, height: 0, depthOrArrayLayers: 13}); |
| } catch {} |
| document.body.append(canvas0); |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 6, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 51, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 122, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let buffer94 = device0.createBuffer({size: 272, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer95 = device0.createBuffer({size: 356, usage: GPUBufferUsage.COPY_SRC}); |
| let commandEncoder121 = device0.createCommandEncoder(); |
| let texture127 = device0.createTexture({ |
| size: {width: 180, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder19 = commandEncoder58.beginRenderPass({ |
| colorAttachments: [{view: textureView67, depthSlice: 35, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(8); |
| } catch {} |
| try { |
| offscreenCanvas2.getContext('webgpu'); |
| } catch {} |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup49); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer68, 12); }; |
| } catch {} |
| try { |
| commandEncoder34.insertDebugMarker('\ufc15'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 64, new Uint32Array(10756).map((_, i) => i * 4), 409, 0); |
| } catch {} |
| let commandEncoder123 = device0.createCommandEncoder({}); |
| let textureView122 = texture50.createView({baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup33, new Uint32Array(383), 0, 0); |
| } catch {} |
| try { |
| commandEncoder76.insertDebugMarker('\u0a7d'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let texture128 = device0.createTexture({ |
| size: [30, 1, 1], |
| dimension: '2d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView123 = texture11.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer6, 24); }; |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u4f6b'); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 56, resource: textureView23}, |
| {binding: 8, resource: textureView7}, |
| {binding: 591, resource: textureView53}, |
| {binding: 1, resource: textureView29}, |
| ], |
| }); |
| let commandEncoder125 = device0.createCommandEncoder(); |
| let texture129 = device0.createTexture({size: [7, 1, 6], format: 'r8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer68, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(2, buffer17, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup30, new Uint32Array(790), 4, 0); |
| } catch {} |
| try { |
| commandEncoder115.copyTextureToBuffer({ |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 50, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2740 */ |
| offset: 2740, |
| bytesPerRow: 22016, |
| buffer: buffer7, |
| }, {width: 8, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| let buffer96 = device0.createBuffer({size: 180, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer87, 'uint32', 16, 15); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToTexture({ |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder10.insertDebugMarker('\u0d05'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let buffer97 = device0.createBuffer({size: 76, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder126 = device0.createCommandEncoder({label: '\u{1fb25}\ud1e6\u0c15\u0a9e\ud8d6\u8d4e\u244e\u{1ff69}'}); |
| let texture130 = device0.createTexture({ |
| size: {width: 1, height: 540, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup46, new Uint32Array(1706), 60, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder14.dispatchWorkgroupsIndirect(buffer59, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer66, 32, new Float32Array(16583).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.236)), 2140, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(169).fill(59), /* required buffer size: 169 */ |
| {offset: 169}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 1, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup47, new Uint32Array(2044), 29, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup26, new Uint32Array(891), 138, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer66, 'uint16', 22, 65); |
| } catch {} |
| let bindGroup53 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let buffer98 = device0.createBuffer({ |
| size: 38, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture131 = device0.createTexture({ |
| size: [60, 1, 103], |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup16); |
| } catch {} |
| document.body.append(canvas0); |
| let offscreenCanvas3 = new OffscreenCanvas(147, 272); |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| let texture132 = device0.createTexture({ |
| size: [15], |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView124 = texture23.createView({dimension: '2d'}); |
| let sampler19 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 36.79}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(1, bindGroup33); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup10, new Uint32Array(5265), 496, 0); |
| } catch {} |
| try { |
| commandEncoder63.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1112 */ |
| offset: 1112, |
| buffer: buffer7, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer99 = device0.createBuffer({size: 92, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup8, new Uint32Array(1164), 77, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer87, 0); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder93.clearBuffer(buffer93, 0, 0); |
| } catch {} |
| let gpuCanvasContext3 = offscreenCanvas3.getContext('webgpu'); |
| let recycledExplicitBindGroupLayout10 = pipeline7.getBindGroupLayout(0); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let commandBuffer10 = commandEncoder74.finish(); |
| let texture133 = device0.createTexture({ |
| size: [64, 64, 162], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer67, 'uint32', 120, 140); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1504 */ |
| offset: 1504, |
| buffer: buffer33, |
| }, { |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout4, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let textureView125 = texture124.createView({format: 'rg8sint', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer12); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToBuffer(buffer27, 12, buffer14, 0, 8); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let buffer100 = device0.createBuffer({ |
| size: 116, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView126 = texture81.createView({}); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| adapter0.label = '\udad9\u0a49'; |
| } catch {} |
| let recycledExplicitBindGroupLayout11 = pipeline15.getBindGroupLayout(1); |
| let bindGroup55 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout9, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let buffer101 = device0.createBuffer({size: 372, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(2, buffer31, 0, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let buffer102 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| let texture134 = device0.createTexture({ |
| size: [75, 1, 1], |
| mipLevelCount: 4, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup49, new Uint32Array(574), 163, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer71, 'uint16', 4, 52); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer39, 0, 8); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer101.unmap(); |
| } catch {} |
| document.body.append(canvas0); |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt470m', transfer: 'bt2020_10bit'} }); |
| let commandBuffer11 = commandEncoder28.finish(); |
| let texture135 = device0.createTexture({ |
| size: {width: 15, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| dimension: '2d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView127 = texture107.createView({}); |
| let renderPassEncoder20 = commandEncoder114.beginRenderPass({ |
| label: '\u{1ff60}\uaeed\u050b\u3e9a\u867b\u34d5\u01c2\u604c\u0d41', |
| colorAttachments: [{ |
| view: textureView56, |
| clearValue: { r: 693.2, g: 358.1, b: -572.6, a: 240.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder19.beginOcclusionQuery(10); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup33); |
| } catch {} |
| try { |
| commandEncoder42.copyBufferToBuffer(buffer27, 12, buffer13, 12, 28); |
| } catch {} |
| let recycledExplicitBindGroupLayout12 = pipeline15.getBindGroupLayout(0); |
| try { |
| computePassEncoder26.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup39, new Uint32Array(980), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline17); |
| } catch {} |
| let gpuCanvasContext4 = canvas3.getContext('webgpu'); |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| let texture136 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView128 = texture2.createView({}); |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| renderBundleEncoder16.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer100); |
| } catch {} |
| try { |
| adapter0.label = '\u1c78\ufcd7\u{1fc5d}\u{1f8ce}\u{1f809}\u5449\u{1f8cf}\u6b6b\u34ce\u{1fed5}'; |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [{binding: 133, resource: {buffer: buffer49, offset: 2560}}], |
| }); |
| let buffer103 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let renderPassEncoder21 = commandEncoder7.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| depthSlice: 63, |
| clearValue: { r: 669.3, g: -603.3, b: 468.0, a: 247.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 147244586, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer20, 'uint16', 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(2, bindGroup30, new Uint32Array(5172), 214, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 1, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder132 = device0.createCommandEncoder(); |
| let textureView129 = texture29.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup18); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer93, 4); }; |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(61); }; |
| } catch {} |
| let computePassEncoder28 = commandEncoder87.beginComputePass(); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder28.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup51, new Uint32Array(468), 8, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.append(canvas2); |
| let bindGroup57 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let textureView130 = texture66.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderPassEncoder22 = commandEncoder105.beginRenderPass({colorAttachments: [{view: textureView31, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder7.setVertexBuffer(1, buffer103, 0); |
| } catch {} |
| try { |
| commandEncoder125.resolveQuerySet(querySet1, 482, 0, buffer34, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer89, 40, new DataView(new Uint8Array(9137).map((_, i) => i).buffer), 43, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture137 = device0.createTexture({ |
| size: [1, 270, 105], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder29 = commandEncoder111.beginComputePass(); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup50, new Uint32Array(1103), 155, 0); |
| } catch {} |
| try { |
| computePassEncoder14.end(); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline6); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer67, 'uint16', 30, 61); |
| } catch {} |
| let buffer104 = device0.createBuffer({size: 7, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup41, new Uint32Array(390), 50, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer76, 'uint32', 20, 2); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| commandEncoder121.insertDebugMarker('\u391f'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 6, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture138 = device0.createTexture({ |
| size: {width: 45, height: 12, depthOrArrayLayers: 35}, |
| sampleCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup55, new Uint32Array(2590), 1_348, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer27, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer41, 52, new DataView(new Uint8Array(2246).map((_, i) => i).buffer), 116, 32); |
| } catch {} |
| let imageData17 = new ImageData(132, 80); |
| let bindGroup58 = device0.createBindGroup({layout: veryExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let buffer105 = device0.createBuffer({size: 252, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer46, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer100); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer71, 'uint16', 32, 3); |
| } catch {} |
| try { |
| commandEncoder42.resolveQuerySet(querySet0, 3, 0, buffer105, 0); |
| } catch {} |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup44, new Uint32Array(1703), 110, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 37, height: 1, depthOrArrayLayers: 45} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 3, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 5}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise22 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, constants: {}, targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.RED}]}, |
| vertex: { |
| module: shaderModule6, |
| buffers: [ |
| { |
| arrayStride: 16, |
| attributes: [ |
| {format: 'float16x4', offset: 0, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 2}, |
| {format: 'float32x3', offset: 0, shaderLocation: 3}, |
| {format: 'float32x3', offset: 0, shaderLocation: 5}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 0}, |
| {format: 'float16x4', offset: 0, shaderLocation: 13}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let texture139 = device0.createTexture({ |
| size: {width: 22, height: 6, depthOrArrayLayers: 57}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView131 = texture69.createView({format: 'rgba8unorm', arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer0, 'uint32', 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture124, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(2_823).fill(32), /* required buffer size: 2_823 */ |
| {offset: 48, bytesPerRow: 37, rowsPerImage: 75}, {width: 1, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let bindGroup59 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout9, |
| entries: [{binding: 133, resource: {buffer: buffer49, offset: 256}}], |
| }); |
| let commandEncoder133 = device0.createCommandEncoder({}); |
| let texture140 = device0.createTexture({ |
| size: {width: 18}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup33); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline4); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'iec61966-2-1'} }); |
| let sampler20 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.24, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(3877), 970, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup31, new Uint32Array(1068), 79, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(2, buffer27, 16, 15); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let texture141 = device0.createTexture({ |
| size: {width: 75, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(1113), 109, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup53, new Uint32Array(1059), 244, 0); |
| } catch {} |
| try { |
| commandEncoder43.resolveQuerySet(querySet0, 0, 1, buffer3, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: []}); |
| let commandBuffer12 = commandEncoder12.finish(); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer71, 'uint16', 4, 6); |
| } catch {} |
| try { |
| commandEncoder30.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2276 */ |
| offset: 2276, |
| buffer: buffer37, |
| }, { |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12, commandBuffer11]); |
| } catch {} |
| let img0 = await imageWithData(38, 38, '#10101010', '#20202020'); |
| let bindGroup61 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout9, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let texture142 = device0.createTexture({ |
| size: {width: 1, height: 135, depthOrArrayLayers: 1}, |
| mipLevelCount: 8, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder19.setStencilReference(218); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(7, buffer103, 52, 0); |
| } catch {} |
| try { |
| commandEncoder112.copyTextureToBuffer({ |
| texture: texture139, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 11}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4454 */ |
| offset: 4454, |
| buffer: buffer7, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let bindGroup62 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [{binding: 133, resource: {buffer: buffer49, offset: 0, size: 4760}}], |
| }); |
| let computePassEncoder30 = commandEncoder40.beginComputePass({ |
| timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 5, endOfPassWriteIndex: 4294967295}, |
| }); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup62, new Uint32Array(1649), 136, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup46, new Uint32Array(869), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup0, new Uint32Array(3519), 315, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer100, 'uint32', 24, 34); |
| } catch {} |
| try { |
| commandEncoder24.resolveQuerySet(querySet1, 139, 4, buffer92, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 37, height: 1, depthOrArrayLayers: 45} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 1, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(imageData14); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer74, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup31, new Uint32Array(462), 62, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer6, 'uint16', 18, 41); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer86); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout9]}); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let texture143 = device0.createTexture({ |
| size: [1, 1080, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8sint'], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer6, 16); }; |
| } catch {} |
| try { |
| computePassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setBlendConstant({ r: 371.9, g: -393.1, b: 87.12, a: 699.7, }); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer66, 'uint32', 4, 10); |
| } catch {} |
| try { |
| commandEncoder118.clearBuffer(buffer89); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 4, new Uint32Array(7086).map((_, i) => i * 3), 314, 12); |
| } catch {} |
| document.body.append(img0); |
| let buffer106 = device0.createBuffer({size: 180, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandBuffer13 = commandEncoder26.finish(); |
| let texture144 = device0.createTexture({size: [1], mipLevelCount: 1, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| try { |
| commandEncoder86.insertDebugMarker('\uc72d'); |
| } catch {} |
| let pipeline20 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule4, constants: {}}}); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer107 = device0.createBuffer({size: 96, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder135 = device0.createCommandEncoder(); |
| let texture145 = device0.createTexture({ |
| size: [1, 540, 1], |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderBundleEncoder3.drawIndirect(buffer94, 116); |
| } catch {} |
| let commandBuffer14 = commandEncoder0.finish(); |
| let texture146 = device0.createTexture({ |
| label: '\u2c30\ub4f4', |
| size: [7, 1, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let texture147 = gpuCanvasContext4.getCurrentTexture(); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup48); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer11, 'uint16', 22, 10); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 90, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup63 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: {buffer: buffer84}}]}); |
| let textureView132 = texture102.createView({}); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer73, 4); }; |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(1, buffer27, 0, 78); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 0, new Uint16Array(7131).map((_, i) => i + 2), 852, 8); |
| } catch {} |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 18, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 68, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 105, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 106, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }, |
| { |
| binding: 118, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 132, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 144, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| {binding: 257, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 383, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 421, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 556, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup48, new Uint32Array(478), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(7, buffer87); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 220 */ |
| offset: 220, |
| bytesPerRow: 9472, |
| buffer: buffer73, |
| }, { |
| texture: texture45, |
| mipLevel: 1, |
| origin: {x: 0, y: 14, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 13, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 36, new Float32Array(54882).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7118)), 42487, 0); |
| } catch {} |
| let pipeline21 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4}}); |
| let bindGroup64 = device0.createBindGroup({ |
| label: '\u{1fa5a}\u88a5\ua02b\u0b05\u{1fc7b}\u053f\u39c5', |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 8, resource: textureView128}, |
| {binding: 56, resource: textureView94}, |
| {binding: 1, resource: textureView14}, |
| {binding: 591, resource: textureView9}, |
| ], |
| }); |
| try { |
| renderPassEncoder15.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(277, 1, 3_278_110_366, 1); |
| } catch {} |
| let bindGroup65 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let buffer108 = device0.createBuffer({size: 92, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder136 = device0.createCommandEncoder({}); |
| let texture148 = device0.createTexture({ |
| size: {width: 45, height: 12, depthOrArrayLayers: 1}, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer94, 4); }; |
| } catch {} |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(2, buffer39, 0, 3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture142, |
| mipLevel: 4, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(764).fill(121), /* required buffer size: 764 */ |
| {offset: 764, bytesPerRow: 81, rowsPerImage: 32}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas2); |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| let texture149 = device0.createTexture({ |
| size: {width: 64}, |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup22, new Uint32Array(7431), 1_774, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup45); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| let buffer109 = device0.createBuffer({size: 52, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let texture150 = device0.createTexture({ |
| size: [18, 1, 132], |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm']}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer59, 'uint16', 112, 147); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(2, buffer4, 0, 3); |
| } catch {} |
| try { |
| commandEncoder115.resolveQuerySet(querySet1, 95, 0, buffer0, 0); |
| } catch {} |
| let bindGroup66 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 3, resource: sampler13}, |
| {binding: 4, resource: textureView122}, |
| {binding: 90, resource: {buffer: buffer70}}, |
| {binding: 0, resource: textureView106}, |
| {binding: 2, resource: {buffer: buffer51}}, |
| {binding: 1, resource: textureView111}, |
| ], |
| }); |
| let buffer110 = device0.createBuffer({size: 376, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| let textureView133 = texture150.createView({label: '\u0ade\u0832\u6d2f\u9472\u0cdc\uedc1'}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup61); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer74, 20); |
| } catch {} |
| try { |
| commandEncoder71.pushDebugGroup('\u{1ff52}'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 12, y: 1, z: 17}, |
| aspect: 'all', |
| }, new Uint8Array(2_300).fill(152), /* required buffer size: 2_300 */ |
| {offset: 115, bytesPerRow: 21, rowsPerImage: 8}, {width: 1, height: 1, depthOrArrayLayers: 14}); |
| } catch {} |
| let texture151 = device0.createTexture({ |
| size: {width: 30, height: 1, depthOrArrayLayers: 93}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame12}); |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup5, new Uint32Array(404), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(140, 0, 1_237_475_255); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer71, 28); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer39, 0); |
| } catch {} |
| try { |
| commandEncoder112.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1632 */ |
| offset: 1632, |
| bytesPerRow: 26112, |
| buffer: buffer83, |
| }, { |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 14, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer111 = device0.createBuffer({size: 292, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| globalThis.someLabel = shaderModule3.label; |
| } catch {} |
| let textureView134 = texture100.createView({}); |
| let textureView135 = texture60.createView({}); |
| let computePassEncoder31 = commandEncoder75.beginComputePass(); |
| let renderBundle5 = renderBundleEncoder3.finish({}); |
| try { |
| renderPassEncoder13.drawIndirect(buffer46, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 45, height: 12, depthOrArrayLayers: 35} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas4 = document.createElement('canvas'); |
| let bindGroup67 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []}); |
| let texture152 = device0.createTexture({ |
| size: [18], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(416, 0, 161_268_044); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer39, 20); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer89, 'uint16', 0, 15); |
| } catch {} |
| try { |
| await buffer40.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: {x: 0, y: 7, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(44).fill(249), /* required buffer size: 44 */ |
| {offset: 44, rowsPerImage: 20}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline22 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| fragment: { |
| module: shaderModule2, |
| constants: {}, |
| targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 60, |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 4}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 6}, |
| {format: 'float32', offset: 8, shaderLocation: 11}, |
| {format: 'uint8x2', offset: 10, shaderLocation: 5}, |
| {format: 'float32x2', offset: 0, shaderLocation: 2}, |
| {format: 'sint32', offset: 4, shaderLocation: 1}, |
| {format: 'float32x3', offset: 20, shaderLocation: 7}, |
| {format: 'sint16x2', offset: 8, shaderLocation: 0}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 14}, |
| {format: 'sint8x2', offset: 24, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let buffer112 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let textureView136 = texture118.createView({dimension: '2d-array', format: 'rgba8uint', baseArrayLayer: 2, arrayLayerCount: 4}); |
| let textureView137 = texture118.createView({dimension: 'cube-array', baseArrayLayer: 5, arrayLayerCount: 6}); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.86, |
| }); |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer11, 'uint16', 30, 7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer87, 4, new Uint16Array(4512).map((_, i) => i + 4), 7, 4); |
| } catch {} |
| let pipeline23 = await promise22; |
| await gc(); |
| let commandEncoder142 = device0.createCommandEncoder({}); |
| let commandBuffer15 = commandEncoder51.finish(); |
| let texture153 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView138 = texture0.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup65, new Uint32Array(2067), 155, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer6, 12); }; |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer68, 28); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer0, 'uint16', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(2, buffer38, 0, 1); |
| } catch {} |
| document.body.append(img0); |
| let commandBuffer16 = commandEncoder30.finish({}); |
| let texture154 = device0.createTexture({ |
| size: {width: 1, height: 135, depthOrArrayLayers: 1013}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.draw(8, 0, 464_716_317); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer86, 60, 9); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer17); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let videoFrame15 = new VideoFrame(canvas2, {timestamp: 0}); |
| try { |
| renderPassEncoder13.draw(113, 0, 199_978_694); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer98, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup62); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer6, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer46, 4); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder49.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3708 */ |
| offset: 3708, |
| rowsPerImage: 165, |
| buffer: buffer37, |
| }, { |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| let pipeline24 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule2, |
| constants: {}, |
| targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 1220, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 436, shaderLocation: 3}, |
| {format: 'sint8x2', offset: 96, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 12, shaderLocation: 8}, |
| {format: 'sint32x3', offset: 120, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 36, shaderLocation: 12}, |
| {format: 'sint32x3', offset: 68, shaderLocation: 15}, |
| {format: 'float16x2', offset: 0, shaderLocation: 9}, |
| {format: 'unorm8x4', offset: 156, shaderLocation: 2}, |
| {format: 'snorm16x2', offset: 56, shaderLocation: 13}, |
| {format: 'float16x4', offset: 400, shaderLocation: 6}, |
| {format: 'uint16x4', offset: 236, shaderLocation: 4}, |
| {format: 'float16x4', offset: 184, shaderLocation: 10}, |
| {format: 'uint16x2', offset: 472, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 16, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x4', offset: 0, shaderLocation: 0}, |
| {format: 'float32x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'}, |
| }); |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'smpte170m'} }); |
| let bindGroup68 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let textureView139 = texture122.createView({}); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(85, 0, 587_892_391, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer82, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer74, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| let texture155 = device0.createTexture({ |
| size: {width: 150, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder32 = commandEncoder137.beginComputePass(); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup60); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer68, 20); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(3, 0, 0, 293_536_560); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer68, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer34, 'uint16', 0, 1); |
| } catch {} |
| let gpuCanvasContext5 = canvas4.getContext('webgpu'); |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let textureView140 = texture154.createView({dimension: '3d', baseMipLevel: 0}); |
| let textureView141 = texture114.createView({dimension: '2d', format: 'rgba8unorm', baseMipLevel: 0, baseArrayLayer: 1}); |
| let renderBundle6 = renderBundleEncoder8.finish({}); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer39, 8); |
| } catch {} |
| try { |
| commandEncoder71.copyTextureToTexture({ |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 11}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 6, y: 10, z: 72}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer9, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder13.draw(67, 0, 546_983_873); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer59, 'uint16', 40, 133); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(2, buffer107, 0, 3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer41, 8, new Uint32Array(29296).map((_, i) => i * 10), 1865, 16); |
| } catch {} |
| let buffer113 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer46, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer59, 'uint32', 88, 216); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder102.copyBufferToBuffer(buffer44, 0, buffer10, 4, 12); |
| } catch {} |
| try { |
| commandEncoder71.popDebugGroup(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| await gc(); |
| let imageData18 = new ImageData(24, 56); |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpte170m', transfer: 'unspecified'} }); |
| let bindGroup69 = device0.createBindGroup({layout: veryExplicitBindGroupLayout13, entries: [{binding: 2, resource: {buffer: buffer49}}]}); |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 74.60, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup51); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder130.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3980 */ |
| offset: 3980, |
| buffer: buffer37, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 37, height: 1, depthOrArrayLayers: 45} |
| */ |
| { |
| source: canvas4, |
| origin: { x: 52, y: 81 }, |
| flipY: false, |
| }, { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 11}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| canvas0.height = 2395; |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.draw(99, 0, 1_132_538_257); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer75, 40); |
| } catch {} |
| try { |
| buffer86.unmap(); |
| } catch {} |
| try { |
| commandEncoder143.copyBufferToBuffer(buffer7, 172, buffer102, 24, 12); |
| } catch {} |
| try { |
| commandEncoder54.clearBuffer(buffer102); |
| } catch {} |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'gamma22curve'} }); |
| let bindGroup70 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 90, resource: {buffer: buffer84}}, |
| {binding: 3, resource: sampler3}, |
| {binding: 2, resource: {buffer: buffer3, size: 64}}, |
| {binding: 0, resource: textureView106}, |
| {binding: 1, resource: textureView111}, |
| {binding: 4, resource: textureView105}, |
| ], |
| }); |
| let computePassEncoder33 = commandEncoder83.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 162, endOfPassWriteIndex: 298}}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(0, buffer105, 4, 68); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let buffer114 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX}); |
| let renderPassEncoder23 = commandEncoder129.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView85, |
| depthSlice: 497, |
| clearValue: { r: -358.1, g: 319.8, b: -352.0, a: -664.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup28, new Uint32Array(815), 3, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 50}, |
| aspect: 'all', |
| }, new Uint8Array(2_699).fill(40), /* required buffer size: 2_699 */ |
| {offset: 139, bytesPerRow: 10, rowsPerImage: 8}, {width: 2, height: 0, depthOrArrayLayers: 33}); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| let textureView142 = texture13.createView({dimension: '2d'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer74, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder13.end(); |
| } catch {} |
| let pipeline25 = device0.createComputePipeline({ |
| layout: pipelineLayout1, |
| compute: {module: shaderModule1, entryPoint: 'compute1', constants: {28_210: 1}}, |
| }); |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup55); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer105, 'uint16', 10, 7); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer76, 'uint16', 4, 3); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer76, 'uint32', 24, 12); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(5, buffer86, 0, 41); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer15]); |
| } catch {} |
| let textureView143 = texture124.createView({}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup38, new Uint32Array(1105), 228, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer100, 'uint32', 20, 8); |
| } catch {} |
| try { |
| commandEncoder101.copyBufferToBuffer(buffer95, 80, buffer72, 20, 56); |
| } catch {} |
| try { |
| commandEncoder35.resolveQuerySet(querySet1, 721, 202, buffer33, 0); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let img1 = await imageWithData(19, 32, '#10101010', '#20202020'); |
| let commandEncoder147 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(0, buffer39); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(85).fill(69), /* required buffer size: 85 */ |
| {offset: 85}, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| let pipeline26 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout3, |
| multisample: {}, |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-dst'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 44, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32', offset: 0, shaderLocation: 3}, |
| {format: 'sint32x3', offset: 8, shaderLocation: 4}, |
| {format: 'sint32', offset: 0, shaderLocation: 0}, |
| {format: 'float16x2', offset: 8, shaderLocation: 7}, |
| {format: 'float16x2', offset: 8, shaderLocation: 2}, |
| {format: 'float32x2', offset: 0, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 5}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 1}, |
| {format: 'sint32', offset: 0, shaderLocation: 10}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 12, |
| stepMode: 'vertex', |
| attributes: [{format: 'unorm8x4', offset: 0, shaderLocation: 14}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let textureView144 = texture99.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup60, []); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer27); |
| } catch {} |
| let pipeline27 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| constants: {}, |
| targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule6, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x2', offset: 0, shaderLocation: 12}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 2}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 3}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 11}, |
| {format: 'float32', offset: 0, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 248, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x3', offset: 60, shaderLocation: 7}, |
| {format: 'float32x2', offset: 48, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let autogeneratedBindGroupLayout4 = pipeline18.getBindGroupLayout(1); |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| let commandBuffer17 = commandEncoder48.finish(); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup69); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup48, new Uint32Array(1455), 407, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer107, 0, 62); |
| } catch {} |
| try { |
| buffer14.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer110, 12, new Float32Array(9872).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.01457)), 2900, 44); |
| } catch {} |
| let promise25 = device0.queue.onSubmittedWorkDone(); |
| let pipeline28 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x68f7c19}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-src-alpha'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule3, |
| buffers: [ |
| { |
| arrayStride: 52, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 4, shaderLocation: 3}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 2}, |
| {format: 'snorm8x2', offset: 14, shaderLocation: 13}, |
| {format: 'uint32x3', offset: 12, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 1}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 5}, |
| {format: 'unorm16x4', offset: 4, shaderLocation: 4}, |
| {format: 'sint32', offset: 32, shaderLocation: 10}, |
| {format: 'float16x4', offset: 16, shaderLocation: 11}, |
| {format: 'uint8x4', offset: 8, shaderLocation: 15}, |
| {format: 'uint32x2', offset: 8, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 8, shaderLocation: 6}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 7}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x4', offset: 0, shaderLocation: 8}, |
| {format: 'float16x2', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let imageData19 = new ImageData(24, 152); |
| let buffer115 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC}); |
| let texture156 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 381}, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder34 = commandEncoder122.beginComputePass(); |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer38); |
| } catch {} |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer20, 'uint32', 0, 0); |
| } catch {} |
| try { |
| commandEncoder143.copyTextureToBuffer({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1152 */ |
| offset: 1152, |
| bytesPerRow: 2048, |
| buffer: buffer84, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| offscreenCanvas3.width = 170; |
| let buffer116 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder150 = device0.createCommandEncoder({}); |
| let texture157 = device0.createTexture({ |
| size: [37, 1, 236], |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture158 = device0.createTexture({ |
| size: {width: 180, height: 48, depthOrArrayLayers: 33}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView145 = texture151.createView({baseArrayLayer: 6, arrayLayerCount: 22}); |
| let computePassEncoder35 = commandEncoder132.beginComputePass({timestampWrites: {querySet: querySet4}}); |
| try { |
| computePassEncoder34.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer59, 20); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer12, 0, 82); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer71, 'uint16', 0, 3); |
| } catch {} |
| let imageData20 = new ImageData(12, 8); |
| let commandEncoder151 = device0.createCommandEncoder({}); |
| let textureView146 = texture118.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let textureView147 = texture60.createView({}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(87).fill(159), /* required buffer size: 87 */ |
| {offset: 87}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| let imageData21 = new ImageData(68, 88); |
| let bindGroup72 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 591, resource: textureView9}, |
| {binding: 8, resource: textureView7}, |
| {binding: 1, resource: textureView14}, |
| {binding: 56, resource: textureView28}, |
| ], |
| }); |
| let commandEncoder152 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup51, new Uint32Array(1928), 268, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer75, 4); }; |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(2, 108, 5, 247_989_167); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer49, 3_872); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer9, 4); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(0, buffer86); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 0, new Uint32Array(9624).map((_, i) => i * 9), 1058, 4); |
| } catch {} |
| let autogeneratedBindGroupLayout5 = pipeline13.getBindGroupLayout(0); |
| let bindGroup73 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout11, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let commandEncoder153 = device0.createCommandEncoder(); |
| let textureView148 = texture90.createView({}); |
| let textureView149 = texture124.createView({}); |
| try { |
| computePassEncoder5.end(); |
| } catch {} |
| try { |
| computePassEncoder35.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer75, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline10); |
| } catch {} |
| try { |
| buffer110.unmap(); |
| } catch {} |
| try { |
| await buffer2.mapAsync(GPUMapMode.WRITE, 8, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 37, height: 1, depthOrArrayLayers: 45} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 13}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline29 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute4'}}); |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let textureView150 = texture150.createView({format: 'r32float'}); |
| try { |
| renderPassEncoder9.draw(2, 89, 0, 43_614_751); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 317, 0, 244_929_618, 1_167_462_355); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer73, 12); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer73, 16); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup72, new Uint32Array(1068), 119, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(4, buffer105, 0, 30); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| try { |
| commandEncoder71.resolveQuerySet(querySet4, 120, 1, buffer96, 0); |
| } catch {} |
| let buffer117 = device0.createBuffer({ |
| size: 332, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup40, new Uint32Array(867), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer113, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer83, 1_072); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer105, 'uint16', 10, 7); |
| } catch {} |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let textureView151 = texture119.createView({dimension: '2d-array'}); |
| let renderPassEncoder24 = commandEncoder98.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView92, |
| depthSlice: 26, |
| clearValue: { r: 195.4, g: -493.4, b: -140.8, a: -963.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet2, beginningOfPassWriteIndex: 4294967295}, |
| }); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer82, 16); }; |
| } catch {} |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(4, 867, 6, 983_867_018); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 85, 0, 69_104_107, 629_552_529); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer98, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(2, bindGroup21, new Uint32Array(812), 34, 0); |
| } catch {} |
| try { |
| commandEncoder63.copyBufferToTexture({ |
| /* bytesInLastRow: 112 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3464 */ |
| offset: 3464, |
| bytesPerRow: 23808, |
| buffer: buffer83, |
| }, { |
| texture: texture29, |
| mipLevel: 1, |
| origin: {x: 6, y: 7, z: 0}, |
| aspect: 'all', |
| }, {width: 28, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder127.clearBuffer(buffer72, 104, 24); |
| } catch {} |
| await gc(); |
| let bindGroup74 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout12, |
| entries: [{binding: 133, resource: {buffer: buffer49, size: 2744}}], |
| }); |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout8, veryExplicitBindGroupLayout7]}); |
| let textureView152 = texture58.createView({dimension: '2d', mipLevelCount: 1}); |
| let texture159 = device0.createTexture({ |
| size: [1, 135, 1], |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup71, new Uint32Array(1737), 151, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer48, 12); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup14, new Uint32Array(279), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer46, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer111, 0); |
| } catch {} |
| let texture160 = device0.createTexture({ |
| size: {width: 1, height: 270, depthOrArrayLayers: 841}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView153 = texture143.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer93, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup44, new Uint32Array(1716), 67, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(2, buffer105); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 270, depthOrArrayLayers: 264} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 88, y: 261 }, |
| flipY: true, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 0, y: 88, z: 5}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 47, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer85, 40); }; |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer91, 36); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(7, buffer0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(1, bindGroup0, new Uint32Array(231), 23, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup75 = device0.createBindGroup({layout: veryExplicitBindGroupLayout9, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let texture161 = device0.createTexture({ |
| size: {width: 7, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.draw(8, 87, 0, 80_913_950); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer98, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer73, 12); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer48); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 24, new Uint32Array(24979).map((_, i) => i * 6), 3857, 12); |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let bindGroup76 = device0.createBindGroup({ |
| label: '\u2b69\u0a6e\uf830\u059c\u{1fe3e}\u08e4\u{1f654}\u{1feed}\u099f', |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer49}}, |
| {binding: 515, resource: sampler14}, |
| {binding: 100, resource: {buffer: buffer51, offset: 0}}, |
| {binding: 1, resource: {buffer: buffer49}}, |
| {binding: 529, resource: textureView5}, |
| ], |
| }); |
| let buffer118 = device0.createBuffer({size: 28, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandBuffer18 = commandEncoder46.finish(); |
| let texture162 = device0.createTexture({ |
| size: [1, 135, 433], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.draw(7, 292, 10, 210_194_604); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 280, 0, -650_338_813, 197_872_698); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer6, 24); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer7, 0, 981); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(3, buffer71, 24, 4); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14, commandBuffer18, commandBuffer4]); |
| } catch {} |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup77 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| let computePassEncoder36 = commandEncoder106.beginComputePass(); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(6, 216, 12, 892_987_678); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer94, 60); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer87, 'uint16', 18, 4); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer38, 4, 7); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline22); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture12.label; |
| } catch {} |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let textureView154 = texture47.createView({}); |
| let sampler23 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 94.17, |
| }); |
| try { |
| computePassEncoder36.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup51, new Uint32Array(1345), 147, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer85, 52); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer114, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexedIndirect(buffer113, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 80, new Uint32Array(9119).map((_, i) => i * 9), 1923, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture163 = device0.createTexture({size: [1], dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC, viewFormats: []}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer46, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder22.draw(2, 153, 2, 3_843_965_205); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer113, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer20, 'uint16', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder2.draw(1, 14, 0, 136_368_320); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(1, buffer12, 76); |
| } catch {} |
| try { |
| commandEncoder91.insertDebugMarker('\u0658'); |
| } catch {} |
| try { |
| computePassEncoder1.insertDebugMarker('\u8847'); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 11} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 4, y: 127 }, |
| flipY: true, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup73); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 214, 0, 104_111_773, 506_979_589); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer76); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup2); |
| } catch {} |
| let bindGroup78 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 56, resource: textureView23}, |
| {binding: 591, resource: textureView38}, |
| {binding: 1, resource: textureView39}, |
| {binding: 8, resource: textureView7}, |
| ], |
| }); |
| let buffer119 = device0.createBuffer({ |
| size: 56, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture164 = device0.createTexture({ |
| size: {width: 37, height: 1, depthOrArrayLayers: 83}, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder22.drawIndexed(2, 74, 0, 305_479_688, 1_147_229_092); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer117, 12); |
| } catch {} |
| try { |
| renderPassEncoder17.drawIndirect(buffer75, 16); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer73, 44); |
| } catch {} |
| try { |
| commandEncoder112.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 10000 */ |
| offset: 10000, |
| rowsPerImage: 542, |
| buffer: buffer7, |
| }, { |
| texture: texture152, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder138.copyTextureToTexture({ |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup30, new Uint32Array(347), 12, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2, 2); }; |
| } catch {} |
| try { |
| computePassEncoder19.end(); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 96, 0, 297_879_423, 4_294_967_199); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer83, 3_344); |
| } catch {} |
| try { |
| renderBundleEncoder2.draw(1, 260, 0, 362_015_311); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer71, 0); |
| } catch {} |
| try { |
| commandEncoder116.pushDebugGroup('\u{1fdef}'); |
| } catch {} |
| try { |
| commandEncoder116.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer43, 28, new Float16Array(13250).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.076)), 823, 12); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer93, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 485, 0, 366_306_937, 665_549_118); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup52, []); |
| } catch {} |
| try { |
| renderBundleEncoder9.drawIndirect(buffer46, 0); |
| } catch {} |
| try { |
| commandEncoder119.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2344 */ |
| offset: 2344, |
| buffer: buffer83, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame16, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer94, 60); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder9.drawIndirect(buffer6, 12); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer114, 'uint32', 28, 5); |
| } catch {} |
| try { |
| renderPassEncoder23.insertDebugMarker('\u01f5'); |
| } catch {} |
| await gc(); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 82}); |
| let textureView155 = texture19.createView({dimension: '2d', format: 'bgra8unorm', baseArrayLayer: 13, arrayLayerCount: 1}); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup40, new Uint32Array(1062), 217, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 98, 0, 70_803_637, 1_657_808_735); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup75, new Uint32Array(439), 34, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.draw(1, 309, 0, 385_999_097); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexed(3, 425, 0, 496_255_331, 29_981_918); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer103, 24); |
| } catch {} |
| let promise26 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise26; |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder160 = device0.createCommandEncoder(); |
| let texture165 = device0.createTexture({ |
| label: '\u7ecd\ua8f5\ubd95\u98c7\u0bc3\uebf5', |
| size: {width: 1, height: 135, depthOrArrayLayers: 1}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder37 = commandEncoder17.beginComputePass(); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup55, new Uint32Array(3946), 35, 0); |
| } catch {} |
| try { |
| computePassEncoder37.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup61, new Uint32Array(904), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer46, 4); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer38, 'uint16', 4, 2); |
| } catch {} |
| try { |
| commandEncoder90.resolveQuerySet(querySet0, 0, 2, buffer89, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 75, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture31, |
| mipLevel: 1, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline30 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule5, |
| targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 80, |
| attributes: [ |
| {format: 'float32x3', offset: 12, shaderLocation: 13}, |
| {format: 'float32x4', offset: 28, shaderLocation: 3}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 14}, |
| {format: 'snorm8x2', offset: 14, shaderLocation: 12}, |
| {format: 'uint16x2', offset: 4, shaderLocation: 0}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 6}, |
| {format: 'unorm16x2', offset: 8, shaderLocation: 8}, |
| {format: 'snorm8x2', offset: 24, shaderLocation: 4}, |
| ], |
| }, |
| { |
| arrayStride: 468, |
| attributes: [ |
| {format: 'uint16x2', offset: 84, shaderLocation: 9}, |
| {format: 'sint16x2', offset: 8, shaderLocation: 10}, |
| {format: 'uint32x3', offset: 56, shaderLocation: 5}, |
| {format: 'uint32x4', offset: 16, shaderLocation: 7}, |
| {format: 'sint32x4', offset: 256, shaderLocation: 1}, |
| {format: 'uint32x4', offset: 304, shaderLocation: 15}, |
| {format: 'unorm8x2', offset: 16, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 36, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x4', offset: 0, shaderLocation: 11}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| document.body.prepend(canvas1); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout5, autogeneratedBindGroupLayout4]}); |
| try { |
| renderPassEncoder22.drawIndexed(2, 72, 0, -863_506_357, 421_650_737); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(0, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder9.draw(3, 444, 3, 33_642_197); |
| } catch {} |
| let promise27 = device0.queue.onSubmittedWorkDone(); |
| try { |
| renderPassEncoder17.setBlendConstant({ r: 811.1, g: -875.2, b: 373.7, a: -667.3, }); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 39, 0, 570_243_112, 387_347_129); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer118, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer4, 20); |
| } catch {} |
| try { |
| buffer51.unmap(); |
| } catch {} |
| let textureView156 = texture100.createView({}); |
| let textureView157 = texture148.createView({format: 'rgba8unorm'}); |
| let renderBundle7 = renderBundleEncoder9.finish({}); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup71); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup78, []); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer83, 1_372); |
| } catch {} |
| document.body.append(canvas3); |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 90, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView158 = texture33.createView({}); |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer94, 52); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer91, 168); |
| } catch {} |
| document.body.prepend(img1); |
| let img2 = await imageWithData(52, 33, '#10101010', '#20202020'); |
| let textureView159 = texture157.createView({}); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup19, new Uint32Array(3774), 187, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 162, 0, 774_204_905); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 36, 0, 422_603_038, 75_479_940); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(3, bindGroup35, []); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer49, 88); |
| } catch {} |
| try { |
| commandEncoder94.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 288 */ |
| offset: 288, |
| bytesPerRow: 1280, |
| rowsPerImage: 15, |
| buffer: buffer7, |
| }, { |
| texture: texture45, |
| mipLevel: 1, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder24.pushDebugGroup('\ube1a'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture80, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(227).fill(141), /* required buffer size: 227 */ |
| {offset: 227}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup62, new Uint32Array(2474), 241, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 151, 1, 250_414_113); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 119, 0, 250_644_838, 91_387_724); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer94, 24); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer100, 'uint16', 4, 7); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(2, bindGroup35, new Uint32Array(1255), 517, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer114, 'uint32', 8, 20); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(81).fill(90), /* required buffer size: 81 */ |
| {offset: 81}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| canvas2.width = 1494; |
| let bindGroup79 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout12, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup26, new Uint32Array(1969), 149, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 83, 0, -2_099_756_264, 381_813_604); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer74, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer114, 'uint32', 36, 12); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(7, buffer31, 4, 38); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 212 */ |
| offset: 212, |
| buffer: buffer27, |
| }, { |
| texture: texture142, |
| mipLevel: 5, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 56, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 591, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup80 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let commandEncoder162 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup60, new Uint32Array(841), 9, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder21.beginOcclusionQuery(4); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 5, 0, 1_033_757_283); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(1, bindGroup57); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexed(3, 177, 0, -1_838_555_563, 82_620_840); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer6, 'uint32', 0, 3); |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 133, resource: {buffer: buffer84}}]}); |
| let texture166 = device0.createTexture({size: [30], dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView160 = texture94.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder35.setBindGroup(1, bindGroup40, new Uint32Array(2803), 1_333, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer49, 552); }; |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 45, 0, 766_033_900, 74_861_214); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer68, 168); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer6, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(7, buffer7, 6_792, 3_696); |
| } catch {} |
| try { |
| renderBundleEncoder2.draw(1, 25, 0, 1_198_424_887); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToTexture({ |
| /* bytesInLastRow: 14 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2356 */ |
| offset: 2356, |
| buffer: buffer83, |
| }, { |
| texture: texture125, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder24.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 0, new Float32Array(3158).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9790)), 243, 0); |
| } catch {} |
| let pipeline31 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute2'}}); |
| let texture167 = device0.createTexture({ |
| size: [64, 64, 18], |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView161 = texture110.createView({}); |
| try { |
| renderPassEncoder21.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexed(3, 135, 0, 547_477_690, 2_003_878_762); |
| } catch {} |
| try { |
| commandEncoder158.copyBufferToBuffer(buffer37, 2676, buffer102, 16, 20); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1888 */ |
| offset: 1888, |
| rowsPerImage: 68, |
| buffer: buffer83, |
| }, { |
| texture: texture105, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder6.insertDebugMarker('\ud2bf'); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| texture124.label = '\u40a1\u7ba7\u4d3d\u0e27\ue32e'; |
| } catch {} |
| let textureView162 = texture167.createView({baseArrayLayer: 9, arrayLayerCount: 1}); |
| let texture168 = device0.createTexture({ |
| size: [1, 540, 130], |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView163 = texture111.createView({}); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup67, new Uint32Array(47), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer83, 848); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer103, 0, 31); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let commandEncoder163 = device0.createCommandEncoder(); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup60, new Uint32Array(1360), 76, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(5, 75, 7, 889_662_172); |
| } catch {} |
| try { |
| renderBundleEncoder2.draw(1, 383, 0, 30_965_271); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer49, 'uint32', 2_476, 315); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder55.copyTextureToBuffer({ |
| texture: texture132, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1880 */ |
| offset: 1880, |
| bytesPerRow: 11264, |
| buffer: buffer7, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 0, new Uint16Array(10210).map((_, i) => i + 3), 3945, 8); |
| } catch {} |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'gamma22curve'} }); |
| let renderBundle8 = renderBundleEncoder2.finish({}); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup77, new Uint32Array(483), 92, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer103, 0); |
| } catch {} |
| try { |
| commandEncoder148.clearBuffer(buffer29, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(11); }; |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 133, resource: {buffer: buffer84, offset: 0}}], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup81); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup18, new Uint32Array(2517), 435, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(3, 72, 1, 141_372_972); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 16, 0, 32_626_953, 147_595_331); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(4, buffer111); |
| } catch {} |
| try { |
| renderBundleEncoder11.insertDebugMarker('\u{1fbcd}'); |
| } catch {} |
| let commandEncoder164 = device0.createCommandEncoder({}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 11, 0, 373_517_041); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(7, buffer39); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(191).fill(90), /* required buffer size: 191 */ |
| {offset: 191}, {width: 86, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} }); |
| let buffer120 = device0.createBuffer({size: 452, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture169 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 92}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 57, 0, -1_115_105_547, 924_200_010); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| await promise27; |
| } catch {} |
| document.body.append(img2); |
| let buffer121 = device0.createBuffer({size: 123, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let textureView164 = texture101.createView({mipLevelCount: 1, baseArrayLayer: 6, arrayLayerCount: 7}); |
| let textureView165 = texture110.createView({}); |
| try { |
| computePassEncoder35.setBindGroup(0, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 75, 0, 519_367_833); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder18.pushDebugGroup('\u01d1'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer71, 32, new DataView(new ArrayBuffer(71144)), 1268, 0); |
| } catch {} |
| let texture170 = device0.createTexture({ |
| label: '\u089c\u0d6a\u0923\u33c6', |
| size: [150], |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer48, 8); }; |
| } catch {} |
| try { |
| computePassEncoder30.end(); |
| } catch {} |
| try { |
| renderPassEncoder21.beginOcclusionQuery(6); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer68, 56); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer6, 72); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer105, 'uint32', 8, 27); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline23); |
| } catch {} |
| try { |
| computePassEncoder31.insertDebugMarker('\u9bdd'); |
| } catch {} |
| let commandEncoder165 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup77); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 74, 1, 519_949_034); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer117, 128); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup26, []); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(3, bindGroup75, new Uint32Array(699), 406, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer66, 'uint16', 18, 10); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(7); }; |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 1, resource: {buffer: buffer84}}, |
| {binding: 529, resource: textureView46}, |
| {binding: 100, resource: {buffer: buffer67}}, |
| {binding: 515, resource: sampler2}, |
| {binding: 4, resource: {buffer: buffer49}}, |
| ], |
| }); |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let texture171 = device0.createTexture({ |
| size: [1, 540, 1], |
| sampleCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup67, new Uint32Array(2953), 515, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer91, 24); }; |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder21.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(3, 930, 1, 264_963_254); |
| } catch {} |
| try { |
| renderPassEncoder14.drawIndexedIndirect(buffer71, 20); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer75, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline22); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| document.body.append(canvas2); |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let commandBuffer19 = commandEncoder14.finish(); |
| let textureView166 = texture36.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder20.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(1, buffer107); |
| } catch {} |
| try { |
| computePassEncoder31.insertDebugMarker('\u01b1'); |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder(); |
| let textureView167 = texture153.createView({dimension: '2d-array'}); |
| let sampler24 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 94.32}); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup49, new Uint32Array(617), 36, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer9, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(8); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 83, 0, 277_057_715, 362_353_569); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer93, 0); |
| } catch {} |
| let pipeline32 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let texture172 = device0.createTexture({ |
| size: [45], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView168 = texture14.createView({mipLevelCount: 2}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup55, new Uint32Array(942), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 141, 0, -2_145_137_613, 353_602_091); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer117, 24); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup18); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame21 = new VideoFrame(imageBitmap3, {timestamp: 0}); |
| let texture173 = device0.createTexture({ |
| size: [7, 1, 65], |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture174 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView169 = texture36.createView({dimension: '2d-array'}); |
| let computePassEncoder38 = commandEncoder35.beginComputePass(); |
| try { |
| renderPassEncoder9.draw(2, 33, 1, 1_089_825_113); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(3, bindGroup55, new Uint32Array(791), 201, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline30); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer119, 4, new Uint16Array(6538).map((_, i) => i + 8), 39, 4); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout6, entries: [{binding: 133, resource: {buffer: buffer49}}]}); |
| let buffer122 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC}); |
| try { |
| computePassEncoder38.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer49, 296); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer67, 'uint32', 136, 40); |
| } catch {} |
| try { |
| commandEncoder133.copyBufferToBuffer(buffer117, 60, buffer102, 16, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| adapter0.label = '\u08c6\u66b6\ud3b2\uc692\uc9c6\u{1fcde}\u{1fc64}\u07af'; |
| } catch {} |
| let textureView170 = texture117.createView({}); |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup64, new Uint32Array(2099), 294, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(3, buffer105); |
| } catch {} |
| try { |
| await shaderModule3.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder76.insertDebugMarker('\u3cbf'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer101, 72, new Float16Array(6295).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.796)), 368, 32); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 591, resource: textureView142}, |
| {binding: 56, resource: textureView28}, |
| {binding: 8, resource: textureView128}, |
| {binding: 1, resource: textureView14}, |
| ], |
| }); |
| let buffer123 = device0.createBuffer({size: 224, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer75, 8); }; |
| } catch {} |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer9, 24); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer48, 180); |
| } catch {} |
| let promise28 = device0.queue.onSubmittedWorkDone(); |
| let texture175 = device0.createTexture({ |
| label: '\u{1fd43}\uf857\u{1fd34}\u{1ff22}', |
| size: {width: 18, height: 1, depthOrArrayLayers: 1}, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.82, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 52, 0, 1_763_012); |
| } catch {} |
| try { |
| commandEncoder141.resolveQuerySet(querySet5, 5, 1, buffer22, 0); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 1, resource: textureView111}, |
| {binding: 3, resource: sampler9}, |
| {binding: 90, resource: {buffer: buffer51, size: 268}}, |
| {binding: 4, resource: textureView105}, |
| {binding: 0, resource: textureView152}, |
| {binding: 2, resource: {buffer: buffer117}}, |
| ], |
| }); |
| let buffer124 = device0.createBuffer({size: 79, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup80, []); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 333, 0, 43_711_329, 1_600_317_922); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup13, new Uint32Array(2259), 1_086, 0); |
| } catch {} |
| let commandEncoder169 = device0.createCommandEncoder(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup57, new Uint32Array(92), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(17, 358, 2, 320_017_170); |
| } catch {} |
| try { |
| renderPassEncoder18.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 88, 0, 745_265_187); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 66, 0, -1_430_573_302, 335_160_048); |
| } catch {} |
| try { |
| computePassEncoder36.insertDebugMarker('\u930f'); |
| } catch {} |
| let bindGroup87 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 56, resource: textureView135}, |
| {binding: 8, resource: textureView128}, |
| {binding: 591, resource: textureView152}, |
| {binding: 1, resource: textureView39}, |
| ], |
| }); |
| let textureView171 = texture76.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup80, new Uint32Array(2830), 911, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 78, 0, -1_766_764_370, 1_062_849_577); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer118, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer111, 20, 107); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(171); }; |
| } catch {} |
| let buffer125 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder170 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup41, new Uint32Array(1478), 166, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer6, 32); }; |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexed(2, 294, 0, -1_996_967_095, 1_234_905_499); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer59, 16); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer6, 8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer0, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline23); |
| } catch {} |
| try { |
| commandEncoder170.insertDebugMarker('\u811b'); |
| } catch {} |
| try { |
| renderPassEncoder18.insertDebugMarker('\u0537'); |
| } catch {} |
| await gc(); |
| let buffer126 = device0.createBuffer({size: 364, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let commandEncoder171 = device0.createCommandEncoder({}); |
| let texture176 = device0.createTexture({ |
| size: {width: 60, height: 1, depthOrArrayLayers: 104}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder39 = commandEncoder123.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer82, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndexedIndirect(buffer39, 8); |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer39, 20); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer105, 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup33, new Uint32Array(133), 80, 0); |
| } catch {} |
| let pipeline33 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0}}); |
| try { |
| await promise28; |
| } catch {} |
| let imageData22 = new ImageData(64, 80); |
| try { |
| computePassEncoder39.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderPassEncoder22.draw(12, 18, 3, 283_734_772); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer98, 4); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(7, buffer17); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(0, buffer126, 0, 185); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 18, height: 1, depthOrArrayLayers: 45} |
| */ |
| { |
| source: videoFrame19, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture53, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 18}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture177 = device0.createTexture({ |
| size: [90, 24, 1], |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView172 = texture125.createView({dimension: '2d-array', format: 'r8unorm'}); |
| let computePassEncoder40 = commandEncoder49.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder22.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer94, 44); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer85, 4); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup62); |
| } catch {} |
| try { |
| computePassEncoder31.insertDebugMarker('\u5d4a'); |
| } catch {} |
| let textureView173 = texture167.createView({arrayLayerCount: 3}); |
| let textureView174 = texture70.createView({format: 'rgba8unorm'}); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup38, new Uint32Array(1234), 319, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer48, 4); }; |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 376, 1, 689_118_416); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer49, 232); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer75, 36); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer113, 0, 0); |
| } catch {} |
| try { |
| commandEncoder29.copyBufferToBuffer(buffer112, 56, buffer116, 12, 16); |
| } catch {} |
| let recycledExplicitBindGroupLayout13 = pipeline2.getBindGroupLayout(1); |
| let texture178 = device0.createTexture({ |
| size: [1, 1080, 1], |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| let textureView175 = texture48.createView({}); |
| let sampler26 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| lodMaxClamp: 99.20, |
| compare: 'not-equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup18, new Uint32Array(245), 58, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(2, 111, 1, 807_691_270); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer49, 1_188); |
| } catch {} |
| try { |
| commandEncoder157.pushDebugGroup('\u02a2'); |
| } catch {} |
| let pipeline34 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}}); |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let commandBuffer20 = commandEncoder4.finish(); |
| let texture179 = device0.createTexture({ |
| size: [1, 135, 1], |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView176 = texture177.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer113, 0, 6); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer93, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup66); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer121, 32); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline27); |
| } catch {} |
| try { |
| await shaderModule4.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer20]); |
| } catch {} |
| await gc(); |
| let commandBuffer21 = commandEncoder70.finish(); |
| let texture180 = device0.createTexture({ |
| size: {width: 90, height: 24, depthOrArrayLayers: 14}, |
| mipLevelCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle9 = renderBundleEncoder6.finish({}); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer76, 'uint16', 4, 7); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer111, 32, 71); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer48, 'uint16', 112, 29); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer71, 40, new DataView(new ArrayBuffer(53240)), 1929, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 30, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap3, |
| origin: { x: 0, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView177 = texture143.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder19.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer100, 'uint16', 6, 2); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer21, commandBuffer19]); |
| } catch {} |
| let buffer127 = device0.createBuffer({size: 24, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder173 = device0.createCommandEncoder(); |
| let textureView178 = texture150.createView({baseMipLevel: 0}); |
| let textureView179 = texture158.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer71, 'uint32', 0, 23); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer71, 'uint32', 12, 3); |
| } catch {} |
| try { |
| commandEncoder99.copyBufferToBuffer(buffer120, 36, buffer87, 12, 52); |
| } catch {} |
| try { |
| commandEncoder149.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 292 */ |
| offset: 292, |
| buffer: buffer33, |
| }, { |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline35 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule4}}); |
| let texture181 = device0.createTexture({ |
| size: [1, 135, 1], |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup2, new Uint32Array(2576), 456, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer59, 'uint32', 68, 193); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup18, new Uint32Array(684), 299, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer18, 'uint16', 6, 6); |
| } catch {} |
| try { |
| commandEncoder167.copyBufferToBuffer(buffer25, 8, buffer66, 8, 36); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(16); }; |
| } catch {} |
| await gc(); |
| let canvas5 = document.createElement('canvas'); |
| let bindGroup88 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer44}}, |
| {binding: 90, resource: {buffer: buffer49, offset: 2816}}, |
| {binding: 3, resource: sampler17}, |
| {binding: 1, resource: textureView107}, |
| {binding: 4, resource: textureView122}, |
| {binding: 0, resource: textureView106}, |
| ], |
| }); |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| let textureView180 = texture181.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderPassEncoder25 = commandEncoder97.beginRenderPass({ |
| colorAttachments: [{view: textureView93, loadOp: 'load', storeOp: 'discard'}], |
| occlusionQuerySet: querySet5, |
| timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 32}, |
| maxDrawCount: 133163665, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer49, 3_656); }; |
| } catch {} |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| computePassEncoder34.setPipeline(pipeline35); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let pipeline36 = device0.createRenderPipeline({ |
| label: '\uf7b5\u07c0\u{1fabe}\udb38\u0cb6', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule2, |
| targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 484, |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 108, shaderLocation: 7}, |
| {format: 'sint32x3', offset: 104, shaderLocation: 6}, |
| {format: 'uint16x2', offset: 76, shaderLocation: 5}, |
| {format: 'sint32x2', offset: 28, shaderLocation: 4}, |
| {format: 'sint32x4', offset: 24, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 24, shaderLocation: 3}, |
| {format: 'sint32', offset: 0, shaderLocation: 1}, |
| {format: 'unorm16x4', offset: 64, shaderLocation: 2}, |
| {format: 'float16x4', offset: 68, shaderLocation: 11}, |
| {format: 'float32', offset: 16, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 88, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw'}, |
| }); |
| try { |
| renderPassEncoder6.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup87, new Uint32Array(480), 56, 0); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| let gpuCanvasContext6 = canvas5.getContext('webgpu'); |
| document.body.append(canvas3); |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 515, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 529, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let recycledExplicitBindGroupLayout14 = pipeline20.getBindGroupLayout(0); |
| let buffer128 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: false}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer66, 'uint32', 4, 11); |
| } catch {} |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let texture182 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup48); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup74, new Uint32Array(1636), 504, 0); |
| } catch {} |
| try { |
| commandEncoder157.popDebugGroup(); |
| } catch {} |
| try { |
| renderBundleEncoder18.insertDebugMarker('\u05a9'); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame7.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| } |
| async function window1() { |
| let promise0 = navigator.gpu.requestAdapter({}); |
| let promise1 = navigator.gpu.requestAdapter({}); |
| let adapter0 = await navigator.gpu.requestAdapter(); |
| let device0 = await adapter0.requestDevice({ |
| defaultQueue: {}, |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| 'float32-blendable', |
| 'float16-renderable', |
| 'float32-renderable', |
| 'core-features-and-limits', |
| 'timestamp-query', |
| ], |
| }); |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte432', transfer: 'bt2020_12bit'} }); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer0 = device0.createBuffer({size: 136, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false}); |
| let texture0 = device0.createTexture({ |
| size: [4, 6, 1], |
| dimension: '2d', |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout0], |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let textureView0 = texture0.createView({mipLevelCount: 1}); |
| let texture1 = device0.createTexture({size: [4, 6, 1], format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass(); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let texture2 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture3 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32sint'], |
| }); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer1 = device0.createBuffer({size: 536, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let texture4 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1058}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame0}); |
| await gc(); |
| let buffer2 = device0.createBuffer({size: 21, usage: GPUBufferUsage.COPY_DST}); |
| let sampler0 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', compare: 'always'}); |
| let videoFrame1 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| let textureView1 = texture2.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let buffer3 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDIRECT}); |
| let textureView2 = texture4.createView({dimension: '3d'}); |
| let computePassEncoder1 = commandEncoder1.beginComputePass(); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let texture5 = device0.createTexture({ |
| size: [97, 60, 1], |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout2], |
| }); |
| let buffer4 = device0.createBuffer({size: 212, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let sampler1 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat', compare: 'equal'}); |
| let texture6 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView3 = texture0.createView({aspect: 'depth-only', baseMipLevel: 0, baseArrayLayer: 0}); |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1]}); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let textureView4 = texture4.createView({dimension: '3d', arrayLayerCount: 1}); |
| let textureView5 = texture5.createView({aspect: 'all', baseMipLevel: 0}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1}); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let commandEncoder4 = device0.createCommandEncoder(); |
| let texture7 = device0.createTexture({ |
| size: [390, 24, 1], |
| sampleCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture8 = device0.createTexture({ |
| size: [8, 12, 2], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder2 = commandEncoder3.beginComputePass(); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], stencilReadOnly: true}); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let texture9 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let texture10 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView6 = texture8.createView({mipLevelCount: 1}); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let texture11 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], stencilReadOnly: true}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| commandEncoder2.copyBufferToBuffer(buffer0, 48, buffer2, 0, 4); |
| } catch {} |
| try { |
| commandEncoder2.copyTextureToTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 4, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 2, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let textureView7 = texture7.createView({}); |
| let texture12 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 26}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| texture7.destroy(); |
| } catch {} |
| let buffer5 = device0.createBuffer({size: 308, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let texture13 = device0.createTexture({ |
| size: [780, 480, 72], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture14 = device0.createTexture({ |
| size: {width: 195, height: 12, depthOrArrayLayers: 225}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView8 = texture1.createView({dimension: '2d-array'}); |
| try { |
| device0.queue.writeBuffer(buffer2, 0, new Float32Array(21081).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.2245)), 6977, 0); |
| } catch {} |
| let img0 = await imageWithData(71, 74, '#10101010', '#20202020'); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let texture15 = device0.createTexture({size: [390, 24, 1], mipLevelCount: 2, format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder3 = commandEncoder4.beginComputePass(); |
| document.body.append(img0); |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({ |
| size: [16, 24, 1], |
| mipLevelCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView9 = texture6.createView({mipLevelCount: 1}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame1}); |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| commandEncoder5.clearBuffer(buffer2, 12, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 0, new Float64Array(5781).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/5776)), 660, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 52, 96); |
| } catch {} |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt2020', transfer: 'smpte240m'} }); |
| let texture17 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 58}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder4 = commandEncoder2.beginComputePass(); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true}); |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer6 = device0.createBuffer({size: 407, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| let texture18 = device0.createTexture({ |
| size: [1560, 96, 29], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true}); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer1, 'uint16', 106, 40); |
| } catch {} |
| let buffer7 = device0.createBuffer({size: 56, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| try { |
| await promise3; |
| } catch {} |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let computePassEncoder5 = commandEncoder6.beginComputePass(); |
| let canvas0 = document.createElement('canvas'); |
| let renderPassEncoder0 = commandEncoder5.beginRenderPass({ |
| label: '\u70a6\ue607\u4984\u01bf\ud0e2', |
| colorAttachments: [{view: textureView9, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 278214320, |
| }); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let texture19 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 67}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 308, 21); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 4, new Float32Array(6584).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6330)), 1101, 0); |
| } catch {} |
| canvas0.height = 1283; |
| let buffer8 = device0.createBuffer({ |
| label: '\ua4cc\u0a3a\u{1fbbf}\u6cc3\ue25b\u0aff\u9dcb\u071c', |
| size: 56, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder6 = commandEncoder8.beginComputePass(); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer1, 'uint32', 304, 68); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer8, 12); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let buffer9 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let textureView10 = texture15.createView({format: 'r16sint', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder5.insertDebugMarker('\u427b'); |
| } catch {} |
| let buffer10 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView11 = texture9.createView({dimension: '2d-array'}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(0, buffer9, 0, 58); |
| } catch {} |
| document.body.prepend(canvas0); |
| let textureView12 = texture11.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| let computePassEncoder7 = commandEncoder9.beginComputePass(); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 138, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let textureView13 = texture16.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer9, 'uint32', 8, 21); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer9, 'uint32', 12, 54); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 0, new Float32Array(6918).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.843)), 1294, 12); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let textureView14 = texture2.createView({dimension: '2d-array'}); |
| let textureView15 = texture17.createView({baseArrayLayer: 16, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer1, 'uint32', 8, 34); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| globalThis.someLabel = textureView7.label; |
| } catch {} |
| let texture20 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture21 = device0.createTexture({ |
| size: [780], |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 72, 38); |
| } catch {} |
| let textureView16 = texture5.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer5, 80); |
| } catch {} |
| let buffer11 = device0.createBuffer({size: 2008, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer9, 0, 2); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 136, new Float32Array(9294).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.8971)), 2827, 64); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| /* zero global variables used */ |
| fn fn0() { |
| let vf0: vec4f = unpack4x8unorm(unconst_u32(173046604)); |
| if bool(acosh(vec2f(unconst_f32(0.00953), unconst_f32(-0.6875e-3)))[1]) { |
| var vf1: u32 = pack2x16unorm(vec2f(unconst_f32(0.08384e15), unconst_f32(0.1264))); |
| return; |
| } |
| var vf2: vec4u = unpack4xU8(unconst_u32(2932223629)); |
| } |
| |
| struct T1 { |
| @size(20) f0: vec4u, |
| @size(64) f1: array<array<f16, 2>, 8>, |
| @size(360) f2: mat2x4f, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| @size(104) f0: f16, |
| } |
| |
| struct VertexInput0 { |
| @builtin(instance_index) instance_index: u32, |
| @location(7) @interpolate(flat) location_7: f32, |
| @location(1) location_1: u32, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(9) @interpolate(flat, either) location_9: vec4u, |
| @location(12) location_12: vec2f, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput0 { |
| @location(4) location_4: vec2u, |
| @location(15) @interpolate(flat, centroid) location_15: vec4u, |
| @builtin(position) position: vec4f, |
| @location(8) location_8: vec2i, |
| @location(14) @interpolate(flat, centroid) location_14: vec4u, |
| @location(2) @interpolate(flat, sample) location_2: i32, |
| @location(10) @interpolate(linear, sample) location_10: vec2f, |
| @location(0) @interpolate(linear) location_0: vec4f, |
| @location(6) location_6: vec4h, |
| @location(5) @interpolate(flat) location_5: vec2h, |
| @location(9) location_9: vec4h, |
| @location(11) location_11: f32, |
| } |
| |
| struct VertexInput1 { |
| @location(8) location_8: f32, |
| @location(3) location_3: f32, |
| } |
| |
| struct T2 { |
| @size(448) f0: vec2h, |
| @align(32) f1: array<u32>, |
| } |
| |
| @group(1) @binding(26) var st0: texture_storage_3d<rgba8sint, read>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(1) @binding(10) var<storage, read> buffer17: array<array<array<array<array<f16, 1>, 1>, 10>, 3>>; |
| |
| /* used global variables: st0 */ |
| @vertex |
| fn vertex0(@location(14) @interpolate(perspective) location_14: f16, a1: VertexInput0, a2: VertexInput1, @location(6) @interpolate(flat) location_6: vec2u, @location(0) location_0: vec2u, @location(2) @interpolate(perspective) location_2: f32, @location(4) location_4: vec2f) -> VertexOutput0 { |
| var out: VertexOutput0; |
| out.location_10 = vec2f(out.location_5.xx); |
| out = VertexOutput0(vec2u(a1.vertex_index), vec4u(a1.vertex_index), vec4f(bitcast<f32>(a1.vertex_index)), vec2i(i32(a1.vertex_index)), unpack4xU8(a1.vertex_index), bitcast<i32>(a1.vertex_index), unpack2x16snorm(a1.vertex_index), unpack4x8unorm(a1.vertex_index), vec4h(f16(a1.vertex_index)), bitcast<vec2h>(a1.vertex_index), vec4h(f16(a1.vertex_index)), f32(a1.vertex_index)); |
| switch bitcast<u32>(out.location_5) { |
| default { |
| out.location_15 <<= vec4u(a1.location_1); |
| var vf3: VertexInput1 = a2; |
| } |
| case 1769379258: { |
| let ptr0: ptr<function, vec2h> = &out.location_5; |
| fn0(); |
| out.location_4 = vec2u(a1.location_1); |
| fn0(); |
| } |
| } |
| out.location_5 *= vec2h(vec2h(unconst_f16(-4485.6), unconst_f16(-4569.5))); |
| out.location_10 = vec2f((vec3u(unconst_u32(1023506175), unconst_u32(273443277), unconst_u32(161775951)) == vec3u(unconst_u32(370141143), unconst_u32(453008247), unconst_u32(219028505))).rb.yy.xx.xx); |
| let vf4: f32 = out.location_10[unconst_u32(2463031477)]; |
| return out; |
| _ = st0; |
| } |
| |
| /* used global variables: buffer17 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| let ptr1: ptr<storage, f16, read> = &buffer17[arrayLength(&buffer17)][unconst_u32(393825461)][9][0][0]; |
| _ = buffer17; |
| }`, |
| }); |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView7}, |
| {binding: 1, resource: externalTexture2}, |
| {binding: 0, resource: externalTexture0}, |
| ], |
| }); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup0); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470bg', transfer: 'smpte170m'} }); |
| let buffer19 = device0.createBuffer({size: 108, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let textureView17 = texture0.createView({}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer1, 'uint16', 352, 23); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(6, buffer19, 0, 10); |
| } catch {} |
| let buffer20 = device0.createBuffer({size: 232, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let sampler2 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 89.74}); |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup0, new Uint32Array(2090), 92, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 28, new Float32Array(7694).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.128)), 667, 56); |
| } catch {} |
| let buffer21 = device0.createBuffer({ |
| label: '\u{1fe6b}\u95f7\u{1fd46}\u{1fe8b}\u0b75\u0524\u{1f904}\u07a4\u7123', |
| size: 3562, |
| usage: GPUBufferUsage.STORAGE, |
| }); |
| let texture22 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView18 = texture1.createView({}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['r16sint']}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint16', 42, 30); |
| } catch {} |
| try { |
| commandEncoder10.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 7, y: 19, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 424, y: 30, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(27, 147); |
| let commandEncoder16 = device0.createCommandEncoder(); |
| let computePassEncoder8 = commandEncoder11.beginComputePass(); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, depthReadOnly: true}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer19, 'uint32', 4, 5); |
| } catch {} |
| let sampler3 = device0.createSampler({addressModeU: 'mirror-repeat'}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(3965), 398, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder13.clearBuffer(buffer10); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 0, new Uint32Array(1696).map((_, i) => i * 5), 1266, 0); |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 0, resource: externalTexture0}, |
| {binding: 1, resource: externalTexture2}, |
| {binding: 138, resource: textureView13}, |
| ], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup0, new Uint32Array(1881), 277, 0); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView13}, |
| {binding: 1, resource: externalTexture1}, |
| {binding: 0, resource: externalTexture1}, |
| ], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup0, new Uint32Array(1381), 79, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 0, 12); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(1, buffer5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(392).fill(116), /* required buffer size: 392 */ |
| {offset: 68, bytesPerRow: 1, rowsPerImage: 54}, {width: 0, height: 0, depthOrArrayLayers: 7}); |
| } catch {} |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'bt709'} }); |
| let textureView19 = texture8.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let sampler4 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.10, |
| maxAnisotropy: 18, |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: {x: 24, y: 8, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 286 */ |
| offset: 286, |
| bytesPerRow: 10240, |
| buffer: buffer11, |
| }, {width: 27, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer22 = device0.createBuffer({ |
| size: 92, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.72, |
| compare: 'greater-equal', |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 12, 60); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer5, 0, 12); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer19, 0, 16); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires pointer_composite_access; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| enable f16; |
| |
| struct VertexInput2 { |
| @location(11) location_11: f32, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(6) location_6: vec4h, |
| @location(4) @interpolate(flat) location_4: vec2u, |
| @location(3) @interpolate(flat) location_3: vec2u, |
| @location(2) @interpolate(perspective, either) location_2: f16, |
| } |
| |
| struct FragmentOutput0 { |
| @location(0) location_0: vec2i, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| struct VertexInput6 { |
| @location(9) location_9: vec2h, |
| @location(1) @interpolate(flat) location_1: vec2u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct ComputeInput1 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @id(31623) override override1 = false; |
| |
| struct VertexInput5 { |
| @location(15) @interpolate(flat) location_15: vec4u, |
| } |
| |
| struct VertexInput3 { |
| @location(14) @interpolate(perspective) location_14: f16, |
| @location(0) @interpolate(flat, sample) location_0: i32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexInput4 { |
| @location(8) @interpolate(perspective) location_8: f16, |
| @location(5) location_5: f32, |
| @location(7) location_7: i32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(0) var et2: texture_external; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexOutput1 { |
| @location(11) @interpolate(flat, first) location_11: vec4f, |
| @location(7) @interpolate(perspective, sample) location_7: vec2f, |
| @location(1) location_1: vec2i, |
| @invariant @builtin(position) position: vec4f, |
| @location(3) @interpolate(flat, either) location_3: vec2u, |
| @location(8) @interpolate(flat) location_8: vec4u, |
| @location(6) location_6: vec2h, |
| @location(15) @interpolate(flat, center) location_15: vec4h, |
| } |
| |
| struct VertexInput7 { |
| @location(13) location_13: vec4i, |
| } |
| |
| override override0: i32 = 131935833; |
| |
| @group(0) @binding(1) var et3: texture_external; |
| |
| struct ComputeInput0 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| var<private> vp0: vec4f = vec4f(0.08912e16, 0.1392, 0.4787, 0.06014e-45); |
| |
| struct T0 { |
| @align(16) f0: array<atomic<u32>>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: et3 */ |
| @vertex |
| fn vertex1(a0: VertexInput2, a1: VertexInput3, @location(10) @interpolate(flat) location_10: i32, @location(12) @interpolate(linear, center) location_12: vec2h, a4: VertexInput4, a5: VertexInput5, a6: VertexInput6, a7: VertexInput7, @builtin(instance_index) instance_index: u32) -> VertexOutput1 { |
| var out: VertexOutput1; |
| loop { |
| switch i32(out.location_11[unconst_u32(2306066201)]) { |
| case 28606159, default, 719301726 { |
| var vf5: bool = !bool(out.location_6.r); |
| loop { |
| out.position = vec4f(a6.location_9.xxxx.aabb); |
| out.location_11 = vec4f(mix(vec2h(unconst_f16(-1597.5), unconst_f16(8750.8)), vec2h(unconst_f16(1150.9), unconst_f16(12259.7)), vec2h(unconst_f16(4340.7), unconst_f16(9704.3))).grgg.gggg); |
| let vf6: bool = !unconst_bool(true); |
| break; |
| } |
| var vf7: f32 = smoothstep(unconst_f32(-0.00808), unconst_f32(0.2830), unconst_f32(0.05238)); |
| out.location_1 = vec2i(i32(all(vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(false))))); |
| } |
| } |
| let vf8: f32 = out.location_7[pack4x8unorm(refract(vec4f(unconst_f32(0.3008), unconst_f32(0.1538), unconst_f32(0.3642e38), unconst_f32(0.1261e1)), vec4f(unconst_f32(0.2007e16), unconst_f32(0.03631e7), unconst_f32(0.01722e-38), unconst_f32(-0.03821)), unconst_f32(0.00961)))]; |
| var vf9: i32 = override0; |
| let ptr2: ptr<function, vec2f> = &out.location_7; |
| break; |
| _ = override0; |
| } |
| out.location_11 += vec4f(a0.location_6); |
| out.location_3 -= vec2u(bitcast<u32>(a4.location_5)); |
| { |
| out.location_11 = vec4f(vec4f(unconst_f32(0.06696), unconst_f32(0.01411e34), unconst_f32(0.3527e8), unconst_f32(0.1740))); |
| _ = et3; |
| } |
| return out; |
| _ = override0; |
| _ = et3; |
| } |
| |
| /* used global variables: et3 */ |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| var vf10: vec2f = unpack2x16unorm(unconst_u32(112792187)); |
| let ptr3: ptr<function, vec2f> = &vf10; |
| vf10 -= vec2f(step(vec2h(unconst_f16(7356.2), unconst_f16(-7230.6)), vec2h(unconst_f16(-12137.7), unconst_f16(1089.6)))); |
| let ptr4: ptr<function, u32> = &out.sample_mask; |
| let ptr5: ptr<function, vec2i> = &out.location_0; |
| var vf11: vec2i = select(vec2i(unconst_i32(243887591), unconst_i32(-42649991)), vec2i(unconst_i32(211267511), unconst_i32(37075320)), vec2<bool>(unconst_bool(false), unconst_bool(false))); |
| loop { |
| var vf12: vec3h = trunc(vec3h((vec3u(unconst_u32(894803911), unconst_u32(514287009), unconst_u32(34081382)) >= vec3u(unconst_u32(1891560520), unconst_u32(397399290), unconst_u32(1297236704))))); |
| out.location_0 -= bitcast<vec2i>(textureDimensions(et3)); |
| var vf13: f16 = vf12[unconst_u32(1223018598)]; |
| break; |
| _ = et3; |
| } |
| return out; |
| _ = et3; |
| } |
| |
| /* used global variables: et2 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute1(a0: ComputeInput0, a1: ComputeInput1) { |
| vp0 *= vec4f(vec4f(unconst_f32(0.1045), unconst_f32(0.2375e6), unconst_f32(0.09954e38), unconst_f32(0.2263))); |
| vp0 = vec4f(insertBits(vec2u(unpack4x8unorm(unconst_u32(785751675)).yz.rg), vec2u(unconst_u32(177140341), unconst_u32(3925648177)), unconst_u32(1938095415), unconst_u32(759749759)).gggr.rgbg); |
| var vf14: bool = override1; |
| vp0 = vec4f(vp0[vec3u(cross(vec3f(unconst_f32(0.08826e31), unconst_f32(0.03036), unconst_f32(0.1300e-22)), vec3f(unconst_f32(0.02982e-31), unconst_f32(0.3194), unconst_f32(0.03868))))[0]]); |
| _ = et2; |
| vp0 += normalize(vec3f(unconst_f32(0.4261), unconst_f32(-0.00576), unconst_f32(0.1968e-3))).yzyy; |
| _ = override1; |
| _ = et2; |
| }`, |
| }); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let textureView20 = texture5.createView({format: 'r32sint'}); |
| let texture23 = device0.createTexture({ |
| size: {width: 195, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView21 = texture1.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(1985), 67, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(132540)), 4492, 0); |
| } catch {} |
| let pipeline0 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu'); |
| let imageData0 = new ImageData(124, 16); |
| let texture24 = device0.createTexture({ |
| size: [8, 12, 2], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView22 = texture3.createView({format: 'rg32sint', baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer9, 0, 46); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer19, 'uint32', 8, 30); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(videoFrame0); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let textureView23 = texture20.createView({dimension: '2d-array'}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer5, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(10000), 511, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| struct VertexInput9 { |
| @location(6) location_6: vec4h, |
| @location(2) location_2: u32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(58) var<storage, read_write> buffer25: array<array<f16, 96>, 3>; |
| |
| struct T3 { |
| @align(16) f0: array<f32>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T0 { |
| @size(104) f0: array<vec4<bool>, 1>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: buffer23 */ |
| @must_use |
| fn fn5(a0: ptr<function, vec4i>) -> f16 { |
| var out: f16; |
| _ = fn0(array<vec2f, 1>(vec2f((vec2f(unconst_f32(0.07805), unconst_f32(0.05857e10)) == vec2f(unconst_f32(0.1374e30), unconst_f32(0.03705)))))); |
| buffer23.f0[unconst_u32(269043619)] = sqrt(vec2f(unconst_f32(-0.1175e-7), unconst_f32(0.01389)))[1]; |
| return out; |
| _ = buffer23; |
| } |
| |
| /* used global variables: buffer24 */ |
| fn fn4(a0: vec4i) { |
| var vf24: vec3u = extractBits(vec3u(unconst_u32(786886861), unconst_u32(475171122), unconst_u32(650024904)), unconst_u32(76043755), unconst_u32(477007050)); |
| vf24 -= vec3u(u32(distance(vec3h(unconst_f16(15351.6), unconst_f16(25980.2), unconst_f16(3272.2)), vec3h(unconst_f16(2279.0), unconst_f16(12575.7), unconst_f16(2497.1))))); |
| vf24 <<= vec3u(bitcast<u32>(a0[unconst_u32(519162206)])); |
| _ = fn0(array<vec2f, 1>(vec2f(vp1[0].fract))); |
| vp1[unconst_u32(1100594457)].fract -= vec4f((*&buffer24)).x; |
| let vf25: vec4i = a0; |
| vp1[unconst_u32(2099673272)] = modf(f32((*&buffer24)[unconst_u32(408836050)])); |
| vf24 = bitcast<vec3u>(a0.rbr); |
| for (var it0=pack4xU8((vec4u(unconst_u32(605176588), unconst_u32(2969884591), unconst_u32(659822346), unconst_u32(584850938)) << vec4u(unconst_u32(384454762), unconst_u32(17341885), unconst_u32(911843904), unconst_u32(1260761482)))); it0<(bitcast<u32>(vp1[0].whole) & 0xfff); it0++) { |
| let ptr8 = &vp1[0]; |
| var vf26 = fn0(array<vec2f, 1>(acosh(vec3f(unconst_f32(0.1781e21), unconst_f32(0.1840), unconst_f32(-0.4401e-44))).xz)); |
| return; |
| } |
| vp1[unconst_u32(114674974)] = modf(bitcast<vec4f>(a0.rgag.yxwz)[0]); |
| switch bitcast<u32>(vp1[unconst_u32(475360472)].fract) { |
| case default: { |
| vp1[unconst_u32(109879857)].whole = vp1[0].fract; |
| vp1[0].whole = vp1[unconst_u32(140978453)].whole; |
| vp1[0] = modf(f32((*&buffer24).g)); |
| _ = buffer24; |
| } |
| case 308324724, 285053377: { |
| _ = fn0(array<vec2f, 1>(vec2f(vp1[0].fract))); |
| } |
| } |
| let vf27: u32 = vf24[unconst_u32(269977601)]; |
| _ = buffer24; |
| } |
| |
| struct T1 { |
| f0: array<atomic<u32>>, |
| } |
| |
| /* used global variables: buffer24, buffer25 */ |
| fn fn3() -> vec4h { |
| var out: vec4h; |
| var vf19 = fn1(&vw0); |
| let vf20: bool = (unconst_u32(445472895) == unconst_u32(283079596)); |
| atomicCompareExchangeWeak(&vw2, unconst_u32(799212354), unconst_u32(1038856112)); |
| loop { |
| var vf21: u32 = atomicLoad(&(*&vw2)); |
| let vf22: u32 = extractBits(unconst_u32(363815926), unconst_u32(264073390), unconst_u32(229757419)); |
| break; |
| } |
| var vf23: u32 = pack4xI8(vec4i(unconst_i32(787156152), unconst_i32(201593546), unconst_i32(324172652), unconst_i32(1190675155))); |
| buffer25[unconst_u32(121285257)][unconst_u32(454559093)] = (*&buffer24)[3]; |
| return out; |
| _ = buffer24; |
| _ = buffer25; |
| } |
| |
| /* zero global variables used */ |
| fn fn2() { |
| vp1[unconst_u32(1338560693)].fract = f32(all(unconst_bool(true))); |
| var vf16: vec4f = unpack4x8snorm(bitcast<u32>(unpack4xI8(bitcast<u32>(asinh(vec3f(unconst_f32(0.1943), unconst_f32(0.1307e-39), unconst_f32(0.1608e-21)))[2]))[1])); |
| vf16 = vec4f(vp1[unconst_u32(539575389)].whole); |
| let vf17: vec2f = step(vec2f(unconst_f32(0.2272), unconst_f32(0.07497)), vec2f(cosh(vec3h(unconst_f16(7157.2), unconst_f16(4093.8), unconst_f16(27726.1))).gg.rg.xy)); |
| var vf18: vec4i = unpack4xI8(u32(all(unconst_bool(false)))); |
| } |
| |
| var<workgroup> vw1: array<atomic<u32>, 1>; |
| |
| struct ComputeInput4 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| struct ComputeInput2 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| /* zero global variables used */ |
| fn fn1(a0: ptr<workgroup, vec2f>) -> mat3x2h { |
| var out: mat3x2h; |
| let ptr6: ptr<workgroup, vec2f> = &(*a0); |
| fn0(array<vec2f, 1>(vec2f(f32(out[unconst_u32(551166073)][unconst_u32(2765009761)])))); |
| let ptr7 = &vp1[unconst_u32(327975518)]; |
| return out; |
| } |
| |
| @group(0) @binding(6) var<storage, read_write> buffer23: T3; |
| |
| struct T4 { |
| f0: array<array<vec4<bool>, 1>>, |
| } |
| |
| /* zero global variables used */ |
| fn fn0(a0: array<vec2f, 1>) -> array<array<vec2h, 14>, 2> { |
| var out: array<array<vec2h, 14>, 2>; |
| vp1[unconst_u32(2338802874)].fract *= bitcast<vec4f>(unpack4xI8(u32(out[1][13][unconst_u32(109582376)]))).z; |
| out[bitcast<u32>(out[1][13])][13] *= out[unconst_u32(1685425947)][13]; |
| for (var jj47=0u; jj47<4; jj47++) { out[jj47][unconst_u32(1455711834)] += vec2h(log(vec4f(unconst_f32(0.1553e27), unconst_f32(0.02242), unconst_f32(0.1680e14), unconst_f32(0.3848e-44))).rr.rg.gg.gg.rr.rg.yy.yx); } |
| let vf15: bool = all(unconst_bool(true)); |
| out[unconst_u32(1101547075)][unconst_u32(168691885)] *= vec2h(out[1][13][unconst_u32(774795374)]); |
| return out; |
| } |
| |
| var<workgroup> vw2: atomic<u32>; |
| |
| struct VertexInput8 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct T2 { |
| @size(64) f0: atomic<u32>, |
| @align(32) @size(1248) f1: array<array<vec4u, 1>, 1>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<private> vp1 = array(modf(f32(0.3933e35))); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct ComputeInput3 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @group(0) @binding(43) var<uniform> buffer24: vec4h; |
| |
| struct T5 { |
| @align(64) @size(64) f0: atomic<i32>, |
| @size(64) f1: array<array<array<array<atomic<u32>, 1>, 1>, 1>, 8>, |
| @align(64) @size(384) f2: atomic<i32>, |
| @align(32) f3: array<vec2<bool>>, |
| } |
| |
| var<workgroup> vw0: vec2f; |
| |
| /* used global variables: buffer24 */ |
| @vertex |
| fn vertex2(@location(14) @interpolate(flat) location_14: vec4u, a1: VertexInput8, a2: VertexInput9) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = vec4f(faceForward(vec4h(unconst_f16(-20427.7), unconst_f16(4960.5), unconst_f16(1691.6), unconst_f16(3879.9)), vec4h(unconst_f16(9122.6), unconst_f16(5469.0), unconst_f16(-15225.5), unconst_f16(9752.4)), vec4h(unconst_f16(1180.1), unconst_f16(1175.4), unconst_f16(5941.8), unconst_f16(1361.0)))); |
| out = step(vec2f(unconst_f32(-0.1712), unconst_f32(0.3079e25)), vec2f(unconst_f32(0.00025e-5), unconst_f32(0.07531))).grrr; |
| out += vec4f(f32(a2.location_6[unconst_u32(1866651959)])); |
| vp1[unconst_u32(677603408)].fract = vp1[unconst_u32(252887443)].fract; |
| out *= vec4f(f32((unconst_u32(30334843) >= unconst_u32(69906681)))); |
| let vf28: vec2i = (vec2i(unconst_i32(62308173), unconst_i32(617995507)) ^ vec2i(unconst_i32(410991003), unconst_i32(1655438637))); |
| out *= vec4f((vec4i(unconst_i32(19850344), unconst_i32(-3061137), unconst_i32(191914748), unconst_i32(350943925)) < vec4i(unconst_i32(181195626), unconst_i32(702399807), unconst_i32(-204100208), unconst_i32(357461099))).rgbg); |
| let ptr9 = &vp1[0]; |
| fn4(vec4i(i32(dot(vec2h(unconst_f16(38779.5), unconst_f16(-77.42)), vec2h(unconst_f16(2412.1), unconst_f16(-2271.8)))))); |
| return out; |
| _ = buffer24; |
| } |
| |
| /* used global variables: buffer23 */ |
| @fragment |
| fn fragment1() -> @location(200) @interpolate(linear) i32 { |
| var out: i32; |
| buffer23.f0[bitcast<u32>(ceil(vec2h(unconst_f16(16553.2), unconst_f16(11132.0))))] = vec4f(round(vec4h(unconst_f16(5439.9), unconst_f16(21892.9), unconst_f16(-4122.5), unconst_f16(28794.1))).agag.xwwz.bbgg.yyzw)[0]; |
| return out; |
| _ = buffer23; |
| } |
| |
| /* used global variables: buffer23, buffer24, buffer25 */ |
| @compute @workgroup_size(1, 1, 2) |
| fn compute2(a0: ComputeInput2, a1: ComputeInput3, a2: ComputeInput4) { |
| var vf29: vec3u = a0.global_invocation_id; |
| fn4(bitcast<vec4i>(a1.num_workgroups.ggrb)); |
| buffer23 = (*&buffer23); |
| fn4(unpack4xI8(atomicLoad(&(*&vw1)[unconst_u32(338511088)]))); |
| for (var it1=bitcast<u32>(vp1[0].whole); it1<(bitcast<u32>(countTrailingZeros(vec3i(unconst_i32(66222964), unconst_i32(268121467), unconst_i32(1276884672))).b) & 0xfff); it1++) { |
| vp1[unconst_u32(39587558)].fract = f32((*&buffer25)[unconst_u32(572610426)][95]); |
| _ = fn1(&vw0); |
| _ = buffer25; |
| } |
| let ptr10: ptr<workgroup, array<atomic<u32>, 1>> = &vw1; |
| buffer25[unconst_u32(427693920)][unconst_u32(414501584)] = f16(a0.global_invocation_id.b); |
| fn4(unpack4xI8(atomicLoad(&(*ptr10)[0]))); |
| vf29 = vec3u(u32(buffer23.f0[arrayLength(&buffer23.f0)])); |
| _ = buffer25; |
| _ = buffer23; |
| _ = buffer24; |
| }`, |
| }); |
| let textureView24 = texture24.createView({}); |
| let textureView25 = texture21.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer19); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer1, 'uint16', 12, 104); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 100, new DataView(new Uint8Array(12405).map((_, i) => i).buffer), 1199, 412); |
| } catch {} |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let textureView26 = texture10.createView({format: 'r32sint'}); |
| let sampler6 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.02, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup2, new Uint32Array(255), 3, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(85), 35, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 140, 3); |
| } catch {} |
| try { |
| await buffer10.mapAsync(GPUMapMode.READ); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToBuffer({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 474, y: 5, z: 2}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 136 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 192 */ |
| offset: 192, |
| bytesPerRow: 2048, |
| rowsPerImage: 262, |
| buffer: buffer11, |
| }, {width: 68, height: 34, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture25 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 259}, |
| mipLevelCount: 5, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView27 = texture0.createView({aspect: 'stencil-only'}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer1, 'uint32', 68, 106); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(43).fill(190), /* required buffer size: 43 */ |
| {offset: 43, bytesPerRow: 42}, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture26 = device0.createTexture({ |
| size: [390], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView28 = texture16.createView({dimension: '2d-array', format: 'r32uint'}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let img1 = await imageWithData(21, 53, '#10101010', '#20202020'); |
| let commandEncoder19 = device0.createCommandEncoder(); |
| let texture27 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 598}, |
| dimension: '3d', |
| format: 'r16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint32', 68, 177); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| struct VertexInput10 { |
| @location(1) @interpolate(linear) location_1: vec2f, |
| @location(4) location_4: vec4i, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(9) location_9: f16, |
| } |
| |
| struct T7 { |
| @size(24) f0: vec2<bool>, |
| } |
| |
| struct VertexInput15 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct T11 { |
| @size(3392) f0: T0, |
| @align(16) f1: array<array<T7, 1>>, |
| } |
| |
| struct T13 { |
| f0: array<u32>, |
| } |
| |
| struct T16 { |
| f0: array<u32>, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T15 { |
| @align(16) f0: array<u32>, |
| } |
| |
| @group(0) @binding(6) var<storage, read_write> buffer26: T15; |
| |
| struct VertexInput11 { |
| @location(0) location_0: vec4f, |
| @location(3) location_3: u32, |
| @location(14) @interpolate(flat) location_14: vec2i, |
| } |
| |
| struct T10 { |
| @align(128) @size(1024) f0: T7, |
| @size(384) f1: i32, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T3 { |
| @size(60) f0: atomic<i32>, |
| } |
| |
| @id(62227) override override2: i32 = 598790124; |
| |
| @group(1) @binding(10) var<storage, read> buffer30: array<array<array<array<f16, 3>, 2>, 5>>; |
| |
| struct T6 { |
| f0: array<u32>, |
| } |
| |
| struct VertexOutput2 { |
| @invariant @builtin(position) position: vec4f, |
| } |
| |
| struct T5 { |
| @size(8) f0: atomic<i32>, |
| f1: array<u32>, |
| } |
| |
| var<workgroup> vw4: array<vec4i, 1>; |
| |
| struct T2 { |
| @align(64) @size(192) f0: T1, |
| @size(192) f1: atomic<i32>, |
| f2: array<u32>, |
| } |
| |
| struct VertexInput14 { |
| @location(10) location_10: f32, |
| } |
| |
| var<private> vp2: array<array<array<vec2<bool>, 1>, 31>, 1> = array(array(array(vec2<bool>(true, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array(vec2<bool>(false, true)), array(vec2<bool>(true, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(true, true)), array(vec2<bool>(true, true)), array(vec2<bool>(true, true)), array(vec2<bool>(false, true)), array(vec2<bool>(false, false)), array(vec2<bool>(true, false)), array(vec2<bool>(true, false)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array<vec2<bool>, 1>(vec2<bool>(true, true)), array(vec2<bool>(true, false)), array(vec2<bool>(false, true)), array(vec2<bool>(false, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array(vec2<bool>(false, false)), array<vec2<bool>, 1>(), array(vec2<bool>(false, false)), array(vec2<bool>(false, true)), array<vec2<bool>, 1>(), array<vec2<bool>, 1>(vec2<bool>(true, false)))); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T8 { |
| f0: array<atomic<u32>>, |
| } |
| |
| struct FragmentOutput1 { |
| @location(0) location_0: vec4i, |
| } |
| |
| struct T4 { |
| @size(2048) f0: T1, |
| } |
| |
| @group(1) @binding(3) var<storage, read_write> buffer29: array<array<array<vec2h, 103>, 16>>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T12 { |
| @align(8) @size(24) f0: f16, |
| } |
| |
| struct VertexInput13 { |
| @location(8) location_8: f32, |
| @location(6) @interpolate(linear) location_6: f16, |
| @location(2) location_2: f32, |
| @location(15) @interpolate(flat) location_15: vec4u, |
| } |
| |
| var<workgroup> vw3: array<array<f16, 1>, 1>; |
| |
| struct FragmentInput0 { |
| @location(11) @interpolate(flat, first) location_11: vec4f, |
| } |
| |
| struct VertexInput12 { |
| @location(11) location_11: vec2f, |
| @location(12) location_12: i32, |
| @location(5) @interpolate(flat, centroid) location_5: vec4h, |
| } |
| |
| struct T17 { |
| f0: array<T9>, |
| } |
| |
| struct T0 { |
| @size(64) f0: vec4u, |
| @align(32) @size(896) f1: array<array<array<f16, 1>, 1>, 1>, |
| } |
| |
| struct T14 { |
| f0: array<T7>, |
| } |
| |
| struct FragmentInput1 { |
| @location(8) @interpolate(flat) location_8: vec4u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(1) @binding(115) var st4: texture_storage_2d_array<r32sint, write>; |
| |
| struct T1 { |
| @size(8) f0: i32, |
| f1: array<array<array<vec4f, 1>, 1>, 1>, |
| @align(8) @size(80) f2: f32, |
| } |
| |
| struct T9 { |
| @size(60) f0: atomic<u32>, |
| } |
| |
| @group(0) @binding(3) var tex2: texture_depth_2d; |
| |
| /* used global variables: tex2 */ |
| @vertex @must_use |
| fn vertex3(a0: VertexInput10, a1: VertexInput11, @location(7) @interpolate(perspective, first) location_7: vec2h, @location(13) @interpolate(flat) location_13: vec4f, a4: VertexInput12, a5: VertexInput13, a6: VertexInput14, a7: VertexInput15) -> VertexOutput2 { |
| var out: VertexOutput2; |
| out.position += vec4f(textureDimensions(tex2, unconst_i32(234711125)).rgrr.bgga.aggg.ywww.wxxw); |
| let ptr11: ptr<private, array<vec2<bool>, 1>> = &vp2[0][30]; |
| out.position = vec4f(a4.location_5.arrb); |
| vp2[unconst_u32(3557110492)][unconst_u32(533295629)][unconst_u32(864028017)] = vec2<bool>(textureDimensions(tex2, unconst_i32(393809949))); |
| let ptr12: ptr<private, array<array<vec2<bool>, 1>, 31>> = &vp2[u32(out.position[0])]; |
| out.position += bitcast<vec4f>(a1.location_14.xyxx); |
| return out; |
| _ = tex2; |
| } |
| |
| /* used global variables: buffer26, buffer29, st4 */ |
| @fragment |
| fn fragment2(a0: FragmentInput0, a1: FragmentInput1) -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let ptr13: ptr<private, array<vec2<bool>, 1>> = &vp2[0][30]; |
| let ptr14: ptr<private, vec2<bool>> = &vp2[0][unconst_u32(707809916)][unconst_u32(544944171)]; |
| var vf30: f32 = sin(unconst_f32(-0.5712e-9)); |
| textureStore(st4, vec2i(unconst_i32(30744571), unconst_i32(291866583)), unconst_i32(672367542), vec4i(vec4i(unconst_i32(1260663248), unconst_i32(44205430), unconst_i32(420807019), unconst_i32(343810135)))); |
| vf30 -= f32(all(vec2<bool>(bool(pack4xI8(vec4i(unconst_i32(1364154396), unconst_i32(-28852579), unconst_i32(93426194), unconst_i32(50099796))))))); |
| let ptr15: ptr<private, array<vec2<bool>, 1>> = &vp2[0][30]; |
| for (var jj9=0u; jj9<18; jj9++) { buffer29[unconst_u32(469293485)][jj9][unconst_u32(1126825927)] = bitcast<vec2h>(distance(vec2f(unconst_f32(0.03563), unconst_f32(-0.03330)), vec2f(vp2[0][unconst_u32(907219202)][unconst_u32(1381551462)]))); } |
| let vf31: u32 = a1.location_8[unconst_u32(1476334231)]; |
| out.location_0 = vec4i((*&buffer29)[unconst_u32(751619127)][15][102].xyyx); |
| switch bitcast<i32>((*&buffer29)[unconst_u32(571276440)][unconst_u32(4294967295)][102]) { |
| case default { |
| discard; |
| let ptr16: ptr<storage, T15, read_write> = &buffer26; |
| _ = buffer26; |
| } |
| } |
| return out; |
| _ = buffer26; |
| _ = buffer29; |
| _ = st4; |
| } |
| |
| /* used global variables: buffer30 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute3() { |
| let ptr17: ptr<storage, f16, read> = &buffer30[unconst_u32(312551323)][4][unconst_u32(32212616)][2]; |
| _ = buffer30; |
| }`, |
| }); |
| let buffer32 = device0.createBuffer({size: 120, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, mappedAtCreation: false}); |
| let texture28 = device0.createTexture({ |
| size: [390, 24, 1], |
| format: 'astc-6x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture29 = device0.createTexture({ |
| size: [195, 120, 25], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler7 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.83, |
| maxAnisotropy: 6, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| adapter0.label = '\ud5b9\u6027\u0254'; |
| } catch {} |
| let buffer33 = device0.createBuffer({size: 320, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let texture30 = device0.createTexture({ |
| size: {width: 8, height: 5, depthOrArrayLayers: 1}, |
| format: 'astc-8x5-unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView29 = texture2.createView({mipLevelCount: 1}); |
| let computePassEncoder9 = commandEncoder13.beginComputePass(); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 580}}, |
| {binding: 6, resource: {buffer: buffer22}}, |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 3, resource: textureView3}, |
| ], |
| }); |
| let textureView30 = texture27.createView({dimension: '3d', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup3, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup2, new Uint32Array(626), 61, 0); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder9.pushDebugGroup('\uf6ee'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| adapter0.label = '\u5c9d\u876a\u96ac\u2bea\u0bff\u{1fc9c}\u{1f911}\uc270\u03cf\u{1f713}'; |
| } catch {} |
| let texture31 = device0.createTexture({ |
| size: [195, 12, 270], |
| dimension: '3d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup2, new Uint32Array(653), 148, 0); |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(528), 128, 0); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 3, resource: textureView17}, |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 58, resource: {buffer: buffer21, size: 748}}, |
| {binding: 6, resource: {buffer: buffer5}}, |
| ], |
| }); |
| let texture32 = device0.createTexture({ |
| size: [195], |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| let pipeline1 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8sint'}]}, |
| vertex: { |
| module: shaderModule3, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 76, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x3', offset: 0, shaderLocation: 1}, |
| {format: 'uint32x2', offset: 12, shaderLocation: 3}, |
| {format: 'sint32', offset: 8, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 4, shaderLocation: 13}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 7}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 14}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 15}, |
| {format: 'float16x2', offset: 4, shaderLocation: 9}, |
| {format: 'float32x3', offset: 20, shaderLocation: 0}, |
| {format: 'float32x2', offset: 44, shaderLocation: 2}, |
| {format: 'sint32x3', offset: 12, shaderLocation: 4}, |
| {format: 'snorm8x4', offset: 44, shaderLocation: 8}, |
| {format: 'snorm16x4', offset: 32, shaderLocation: 5}, |
| {format: 'snorm16x4', offset: 32, shaderLocation: 10}, |
| {format: 'float32x3', offset: 0, shaderLocation: 6}, |
| {format: 'unorm16x2', offset: 48, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'back'}, |
| }); |
| let buffer34 = device0.createBuffer({ |
| size: 460, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let texture33 = device0.createTexture({ |
| size: {width: 780}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 3, resource: textureView0}, |
| {binding: 58, resource: {buffer: buffer21, size: 664}}, |
| {binding: 6, resource: {buffer: buffer21, size: 264}}, |
| {binding: 43, resource: {buffer: buffer4}}, |
| ], |
| }); |
| let commandEncoder21 = device0.createCommandEncoder(); |
| let textureView31 = texture32.createView({format: 'rgba8snorm'}); |
| let renderPassEncoder1 = commandEncoder19.beginRenderPass({colorAttachments: [{view: textureView9, loadOp: 'clear', storeOp: 'store'}], maxDrawCount: 280944085}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup3, new Uint32Array(1263), 364, 1); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup2, new Uint32Array(346), 16, 0); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToBuffer(buffer0, 104, buffer2, 0, 0); |
| } catch {} |
| let textureView32 = texture30.createView({}); |
| let textureView33 = texture6.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup1, new Uint32Array(103), 9, 0); |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 408, new DataView(new Uint8Array(10256).map((_, i) => i).buffer), 178, 116); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let textureView34 = texture31.createView({}); |
| let textureView35 = texture4.createView({baseMipLevel: 0, baseArrayLayer: 0}); |
| try { |
| computePassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| commandEncoder9.label = '\u7012\u{1fe8f}\u7fd4\u11b1\u027e\u02dc\uf317'; |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| label: '\u{1f7f2}\ue922\u0cf5', |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 58, resource: {buffer: buffer21, size: 616}}, |
| {binding: 6, resource: {buffer: buffer5}}, |
| {binding: 3, resource: textureView3}, |
| ], |
| }); |
| let textureView36 = texture26.createView({format: 'r32uint'}); |
| let renderPassEncoder2 = commandEncoder22.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView33, |
| clearValue: { r: -754.3, g: -398.8, b: 929.4, a: 730.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup6, new Uint32Array(1839), 278, 1); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 56, y: 6, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(269).fill(148), /* required buffer size: 269 */ |
| {offset: 269, bytesPerRow: 73}, {width: 3, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 684}}, |
| {binding: 6, resource: {buffer: buffer21, size: 80}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 43, resource: {buffer: buffer4, offset: 0}}, |
| ], |
| }); |
| let buffer35 = device0.createBuffer({ |
| size: 108, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let texture34 = device0.createTexture({ |
| size: [780], |
| dimension: '1d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(1571), 24, 1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup6, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder13.insertDebugMarker('\uc626'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 12, new DataView(new ArrayBuffer(9248)), 80, 12); |
| } catch {} |
| let textureView37 = texture34.createView({}); |
| let texture35 = device0.createTexture({size: [4], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer19, 'uint32', 16, 13); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt709', transfer: 'gamma22curve'} }); |
| let buffer36 = device0.createBuffer({size: 64, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let renderPassEncoder3 = commandEncoder17.beginRenderPass({colorAttachments: [{view: textureView33, loadOp: 'load', storeOp: 'discard'}]}); |
| let sampler8 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 86.88}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup7, [0]); |
| } catch {} |
| try { |
| await buffer7.mapAsync(GPUMapMode.READ, 24, 0); |
| } catch {} |
| document.body.append(img1); |
| let buffer37 = device0.createBuffer({size: 992, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 22, 106); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup3, new Uint32Array(1117), 165, 1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer19); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup7, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(7, buffer8); |
| } catch {} |
| let imageData1 = new ImageData(24, 12); |
| let buffer38 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let texture36 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder10 = commandEncoder20.beginComputePass(); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup5, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup7, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(7, buffer19); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture37 = device0.createTexture({size: [195, 120, 1], mipLevelCount: 2, format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView38 = texture36.createView({}); |
| let sampler9 = device0.createSampler({ |
| label: '\u1c7a\u94ee\ucdb1\u81a1', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 11, |
| }); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 76, 235); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(5, buffer35, 48); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer35, 8); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToBuffer({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 60, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 208 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 448 */ |
| offset: 448, |
| bytesPerRow: 14848, |
| buffer: buffer34, |
| }, {width: 78, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer39 = device0.createBuffer({size: 396, usage: GPUBufferUsage.INDIRECT}); |
| try { |
| renderBundleEncoder9.popDebugGroup(); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| struct T1 { |
| @align(64) f0: array<u32>, |
| } |
| |
| struct T5 { |
| f0: array<array<atomic<i32>, 1>>, |
| } |
| |
| struct VertexInput16 { |
| @builtin(instance_index) instance_index: u32, |
| @location(15) @interpolate(flat, first) location_15: vec2i, |
| @location(14) location_14: vec4u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn0() { |
| let vf32: vec3f = log(bitcast<vec3f>((vec4i(unconst_i32(-177637222), unconst_i32(-398695416), unconst_i32(-313458305), unconst_i32(-342832739)) ^ vec4i(unconst_i32(70661769), unconst_i32(1405300125), unconst_i32(163288280), unconst_i32(99644762))).yzw)); |
| var vf33: vec4i = sign(sign(vec4i(unconst_i32(19400813), unconst_i32(149548355), unconst_i32(285166500), unconst_i32(365878168)))); |
| let vf34: f32 = vf32[unconst_u32(617162656)]; |
| var vf35: vec4i = unpack4xI8(unconst_u32(1187123770)); |
| let vf36: i32 = vp3[u32(ldexp(unconst_f16(762.9), unconst_i32(633976614)))]; |
| vf35 = vec4i(vf36); |
| vf33 = vec4i(sin(log(vec2h(unconst_f16(-752.7), unconst_f16(16650.4)))).yxxy); |
| var vf37: vec3f = vf32; |
| var vf38: vec4i = (vf33 ^ vec4i(unconst_i32(402547905), unconst_i32(154428099), unconst_i32(484810277), unconst_i32(-211179582))); |
| let vf39: bool = any(vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false), unconst_bool(true))); |
| return; |
| } |
| |
| struct VertexInput21 { |
| @location(0) location_0: vec4u, |
| } |
| |
| struct VertexInput19 { |
| @location(7) @interpolate(perspective, first) location_7: vec4h, |
| } |
| |
| struct T4 { |
| f0: array<array<array<array<array<vec4f, 1>, 1>, 1>, 1>, 1>, |
| } |
| |
| struct T6 { |
| f0: array<T4, 1>, |
| } |
| |
| @group(0) @binding(3) var tex3: texture_depth_2d; |
| |
| struct VertexOutput3 { |
| @location(7) @interpolate(flat, sample) location_7: vec2f, |
| @location(3) @interpolate(linear, sample) location_3: vec2f, |
| @location(5) @interpolate(flat, sample) location_5: u32, |
| @location(10) @interpolate(flat, first) location_10: vec4i, |
| @location(1) location_1: vec4h, |
| @builtin(position) position: vec4f, |
| } |
| |
| struct T0 { |
| @size(8) f0: u32, |
| @size(96) f1: vec4i, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T3 { |
| @align(8) f0: array<atomic<i32>>, |
| } |
| |
| @group(0) @binding(6) var<storage, read_write> buffer40: T7; |
| |
| struct FragmentInput2 { |
| @location(6) location_6: vec2h, |
| } |
| |
| var<private> vp3: vec4i = vec4i(509626037, 318795331, 473697557, 452286346); |
| |
| struct VertexInput17 { |
| @location(12) location_12: vec4i, |
| } |
| |
| struct VertexInput20 { |
| @location(2) location_2: f16, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(10) @interpolate(perspective, centroid) location_10: vec2f, |
| @location(11) location_11: vec4f, |
| @location(5) location_5: i32, |
| } |
| |
| struct T2 { |
| f0: array<array<atomic<i32>, 1>>, |
| } |
| |
| struct VertexInput18 { |
| @location(8) @interpolate(flat, center) location_8: vec4i, |
| @location(4) location_4: u32, |
| @location(13) @interpolate(perspective, centroid) location_13: f16, |
| @location(9) @interpolate(flat, center) location_9: vec4i, |
| } |
| |
| struct T7 { |
| f0: array<T4>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T8 { |
| @align(64) f0: array<atomic<i32>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: tex3 */ |
| @vertex |
| fn vertex4(@location(6) @interpolate(flat, sample) location_6: vec2i, a1: VertexInput16, a2: VertexInput17, a3: VertexInput18, a4: VertexInput19, @location(1) location_1: vec4u, a6: VertexInput20, a7: VertexInput21, @location(3) location_3: vec4h) -> VertexOutput3 { |
| var out: VertexOutput3; |
| fn0(); |
| let vf40: i32 = a3.location_9[unconst_u32(510904130)]; |
| var vf41: vec2i = a1.location_15; |
| out.position -= vec4f(textureDimensions(tex3, a1.location_15.x).xyyy); |
| vp3 = bitcast<vec4i>(out.location_3.grgr.wxxy); |
| fn0(); |
| let vf42: vec4h = mix(vec4h(unconst_f16(5717.2), unconst_f16(14605.7), unconst_f16(47375.1), unconst_f16(-173.3)), bitcast<vec4h>(a1.location_15), unconst_f16(-995.4)); |
| out.position += a6.location_11; |
| fn0(); |
| vf41 &= bitcast<vec2i>(log2(vec4h(unconst_f16(33637.0), unconst_f16(10557.5), unconst_f16(16811.2), unconst_f16(10619.5)))); |
| fn0(); |
| var vf43: i32 = a3.location_9[unconst_u32(1535792043)]; |
| return out; |
| _ = tex3; |
| } |
| |
| /* used global variables: buffer40 */ |
| @fragment |
| fn fragment3(@location(7) @interpolate(flat) location_7: vec2f, a1: FragmentInput2, @location(1) @interpolate(flat, center) location_1: vec2i) -> @location(200) @interpolate(flat, sample) vec4i { |
| var out: vec4i; |
| fn0(); |
| var vf44: vec2f = (vec2f(unconst_f32(0.00403), unconst_f32(0.1200)) - unconst_f32(-0.1891e36)); |
| vf44 = unpack4x8unorm(unconst_u32(42394638)).xx; |
| fn0(); |
| let ptr18: ptr<storage, array<array<vec4f, 1>, 1>, read_write> = &buffer40.f0[arrayLength(&buffer40.f0)].f0[0][u32((*&buffer40).f0[unconst_u32(880057525)].f0[0][unconst_u32(59116726)][unconst_u32(159701307)][0][0][pack4x8snorm((*&buffer40).f0[arrayLength(&(*&buffer40).f0)].f0[0][unconst_u32(1556081660)][0][unconst_u32(257925210)][unconst_u32(57251579)])])][unconst_u32(2138613235)]; |
| return out; |
| _ = buffer40; |
| }`, |
| }); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer35}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 43, resource: {buffer: buffer37}}, |
| ], |
| }); |
| let buffer43 = device0.createBuffer({size: 28, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let textureView39 = texture22.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup5, new Uint32Array(6321), 201, 1); |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer38.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 48, new Uint32Array(15480).map((_, i) => i * 1), 841, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 68, y: 12, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(99).fill(56), /* required buffer size: 99 */ |
| {offset: 99, bytesPerRow: 92}, {width: 28, height: 28, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'bt709'} }); |
| let commandEncoder25 = device0.createCommandEncoder(); |
| let texture38 = device0.createTexture({ |
| size: [780, 48, 41], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer43, 0); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 690 */ |
| offset: 690, |
| bytesPerRow: 4864, |
| buffer: buffer11, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 28, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder(); |
| let renderPassEncoder4 = commandEncoder16.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView9, |
| clearValue: { r: 510.5, g: -609.7, b: -372.8, a: -915.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup6, [0]); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer38, 'uint16', 6, 12); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 8, new Float32Array(519).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.653)), 69, 4); |
| } catch {} |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let textureView40 = texture24.createView({format: 'r32sint'}); |
| let textureView41 = texture38.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup4, new Uint32Array(182), 31, 1); |
| } catch {} |
| let texture39 = device0.createTexture({ |
| size: [780, 48, 1], |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder11 = commandEncoder18.beginComputePass(); |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer19, 'uint32', 28, 3); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer19, 0, 16); |
| } catch {} |
| let pipeline2 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4}); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup7, new Uint32Array(2977), 198, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer1, 'uint32', 40, 42); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 352, new DataView(new Uint8Array(6049).map((_, i) => i).buffer), 1039, 748); |
| } catch {} |
| document.body.append(canvas0); |
| let textureView42 = texture35.createView({}); |
| let texture40 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 2}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder12 = commandEncoder24.beginComputePass(); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup0, new Uint32Array(790), 293, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup4, [0]); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 35, y: 48, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder14.clearBuffer(buffer7); |
| } catch {} |
| try { |
| adapter0.label = '\ua44b\u0979\u64d5\u5233\ub52b\u6716\u07e4\ufeff\u2592\u{1fc2a}'; |
| } catch {} |
| let texture41 = device0.createTexture({size: {width: 390}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup3, [0]); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer5); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'srgb'}); |
| let img2 = await imageWithData(6, 24, '#10101010', '#20202020'); |
| let bindGroup9 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView7}, |
| {binding: 0, resource: externalTexture7}, |
| {binding: 1, resource: externalTexture0}, |
| ], |
| }); |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer43); |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer5, size: 128}}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 43, resource: {buffer: buffer4, offset: 0}}, |
| {binding: 3, resource: textureView0}, |
| ], |
| }); |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer43, 4, 0); |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 6, resource: {buffer: buffer32}}, |
| {binding: 3, resource: textureView3}, |
| ], |
| }); |
| let buffer44 = device0.createBuffer({size: 182, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView43 = texture32.createView({label: '\ud35c\uf9a8\u67a1\u0392\u3c2c\u393b', mipLevelCount: 1, arrayLayerCount: 1}); |
| let textureView44 = texture28.createView({}); |
| let computePassEncoder13 = commandEncoder25.beginComputePass(); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer19, 'uint32', 24, 11); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer8, 0, 7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 28, new Float32Array(10703).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7637)), 234, 0); |
| } catch {} |
| try { |
| externalTexture1.label = '\ufbe8\u0266\u{1fdf8}\uaef1\u07e3\u00b1\u{1faac}\udd67'; |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }}, |
| {binding: 11, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 29, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 95, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 183, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 216, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 243, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 362, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let computePassEncoder14 = commandEncoder21.beginComputePass(); |
| try { |
| computePassEncoder14.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer9, 'uint32', 20, 13); |
| } catch {} |
| let buffer45 = device0.createBuffer({size: 48, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let textureView45 = texture21.createView({format: 'rg8sint', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| commandEncoder28.copyTextureToBuffer({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 40 */ |
| offset: 40, |
| bytesPerRow: 29440, |
| buffer: buffer44, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder31 = device0.createCommandEncoder(); |
| let querySet0 = device0.createQuerySet({type: 'timestamp', count: 384}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer9, 'uint16', 6, 20); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer1, 'uint32', 44, 74); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView7}, |
| {binding: 1, resource: externalTexture5}, |
| {binding: 0, resource: externalTexture6}, |
| ], |
| }); |
| let textureView46 = texture11.createView({format: 'r32uint'}); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(1189), 209, 1); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(2453), 403, 1); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 163, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 0, y: 5, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 28, new BigInt64Array(7986).map((_, i) => BigInt(i - 2)), 643, 0); |
| } catch {} |
| let buffer46 = device0.createBuffer({size: 61, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder32 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder4.setVertexBuffer(5, buffer43, 4, 5); |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(0) @binding(58) var<storage, read_write> buffer49: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 3>, 4>, 1>, 24>, 1>, 1>>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentOutput2 { |
| @location(7) @interpolate(perspective, sample) location_7: f32, |
| @location(0) @interpolate(flat, first) location_0: vec2i, |
| } |
| |
| override override3: u32 = (140200032 % 103) + 1; |
| |
| struct FragmentInput5 { |
| @location(6) location_6: vec4h, |
| @location(15) @interpolate(flat, centroid) location_15: vec4u, |
| } |
| |
| struct T0 { |
| @size(8) f0: bool, |
| @align(8) @size(96) f1: vec2h, |
| } |
| |
| override override4: u32; |
| |
| struct FragmentInput4 { |
| @location(9) location_9: vec4h, |
| @location(8) location_8: vec2i, |
| @location(4) location_4: vec2u, |
| } |
| |
| struct T1 { |
| @align(8) @size(104) f0: array<f16, 1>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp4 = array(modf(vec3f(0.08166e1, 0.1473e-7, 0.3913e19))); |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentInput3 { |
| @location(0) @interpolate(linear) location_0: vec4f, |
| } |
| |
| var<workgroup> vw5: array<atomic<i32>, 1>; |
| |
| struct ComputeInput5 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct FragmentInput6 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| @group(0) @binding(6) var<storage, read_write> buffer47: vec4f; |
| |
| /* used global variables: buffer47 */ |
| @fragment |
| fn fragment4(@location(14) @interpolate(flat) location_14: vec4u, @location(10) location_10: vec2f, a2: FragmentInput3, @location(5) location_5: vec2h, a4: FragmentInput4, a5: FragmentInput5, a6: FragmentInput6, @location(2) location_2: i32) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| out.location_0 -= vec2i(bitcast<i32>(location_10[location_14[unconst_u32(894580163)]])); |
| var vf45: vec4u = a5.location_15; |
| for (var it2=pack4xU8Clamp(location_14); it2<(bitcast<u32>(out.location_0[unconst_u32(188299568)]) & 0xfff); it2++) { |
| var vf46: vec2u = (vec2u(unconst_u32(1496225667), unconst_u32(1404486959)) << vec2u(unconst_u32(349774633), unconst_u32(108395161))); |
| buffer47 = vec4f(a2.location_0[unconst_u32(601041534)]); |
| let vf47: vec4i = (vec4i(unconst_i32(298060404), unconst_i32(3229128), unconst_i32(175180156), unconst_i32(555301660)) % vec4i(i32(a5.location_6[unconst_u32(321296950)]))); |
| out.location_0 *= vec2i(vp4[0].whole.xx.yy); |
| let vf48: FragmentInput3 = a2; |
| _ = buffer47; |
| } |
| { |
| var vf49: f32 = a2.location_0[unconst_u32(1561018445)]; |
| buffer47 += vp4[unconst_u32(587201661)].whole.xxzx; |
| let ptr19 = &vp4[unconst_u32(1036039377)]; |
| var vf50: f32 = a2.location_0[unconst_u32(54557082)]; |
| var vf51: FragmentInput6 = a6; |
| vp4[unconst_u32(1085529080)] = modf(vp4[unconst_u32(769216155)].fract); |
| _ = buffer47; |
| } |
| let vf52: f32 = location_10[unconst_u32(3531954230)]; |
| out = FragmentOutput2(f32(a4.location_8[unconst_u32(55530851)]), vec2i(a4.location_8[unconst_u32(55530851)])); |
| var vf53: f16 = a4.location_9[unconst_u32(821758682)]; |
| return out; |
| _ = buffer47; |
| } |
| |
| /* used global variables: buffer47, buffer49 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute4(@builtin(local_invocation_index) local_invocation_index: u32, a1: ComputeInput5, @builtin(num_workgroups) num_workgroups: vec3u) { |
| buffer47 -= vec4f(f32((*&buffer49)[unconst_u32(262077955)][unconst_u32(272390449)][unconst_u32(240164927)][23][0][unconst_u32(761907919)][unconst_u32(22269189)][0][0])); |
| buffer49[unconst_u32(692873148)][unconst_u32(733386992)][unconst_u32(372485894)][unconst_u32(305602329)][unconst_u32(1241056263)][unconst_u32(1048625353)][unconst_u32(74794683)][unconst_u32(1310835203)][unconst_u32(882438201)] *= (*&buffer49)[arrayLength(&(*&buffer49))][unconst_u32(665432587)][unconst_u32(502236393)][23][unconst_u32(565667893)][unconst_u32(412589324)][2][unconst_u32(1831110691)][0]; |
| _ = buffer49; |
| _ = buffer47; |
| }`, |
| }); |
| let buffer50 = device0.createBuffer({size: 0, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture42 = device0.createTexture({size: {width: 16}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let renderPassEncoder5 = commandEncoder23.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView33, |
| clearValue: { r: -551.4, g: -180.9, b: -567.5, a: 278.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup3, new Uint32Array(346), 130, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup2, new Uint32Array(1410), 21, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(4, buffer19, 20); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 0, new Uint32Array(1640).map((_, i) => i * 10), 28, 0); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 0, resource: externalTexture3}, |
| {binding: 1, resource: externalTexture0}, |
| {binding: 138, resource: textureView7}, |
| ], |
| }); |
| let commandEncoder33 = device0.createCommandEncoder({label: '\ue962\ua8a7\u46be\u1cb9\u{1fa23}\u913b\u0b0e\u1b06\u{1f919}'}); |
| try { |
| computePassEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(6, buffer19, 16); |
| } catch {} |
| try { |
| await buffer44.mapAsync(GPUMapMode.READ, 0, 28); |
| } catch {} |
| let pipeline3 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}}); |
| let imageData2 = new ImageData(72, 4); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder10.copyBufferToTexture({ |
| /* bytesInLastRow: 68 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1072 */ |
| offset: 1072, |
| bytesPerRow: 1280, |
| buffer: buffer11, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 7, y: 20, z: 0}, |
| aspect: 'all', |
| }, {width: 17, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 0, new BigInt64Array(2923).map((_, i) => BigInt(i - 5)), 205, 4); |
| } catch {} |
| let texture43 = device0.createTexture({ |
| size: [780, 480, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup5, new Uint32Array(676), 41, 1); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer19, 'uint32', 8, 2); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToTexture({ |
| /* bytesInLastRow: 1036 widthInBlocks: 259 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 336 */ |
| offset: 336, |
| buffer: buffer6, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 63, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 259, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderPassEncoder6 = commandEncoder30.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView33, |
| clearValue: { r: -896.3, g: 993.1, b: -610.2, a: 71.10, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 68, endOfPassWriteIndex: 254}, |
| }); |
| try { |
| renderPassEncoder5.setVertexBuffer(3, buffer5); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(6, buffer19, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 58, resource: {buffer: buffer21, size: 1784}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 6, resource: {buffer: buffer22}}, |
| ], |
| }); |
| let buffer51 = device0.createBuffer({size: 296, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let texture44 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 13}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup5, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer1, 'uint32', 4, 214); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(3, buffer5, 4, 8); |
| } catch {} |
| try { |
| renderBundleEncoder16.insertDebugMarker('\u0490'); |
| } catch {} |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let computePassEncoder15 = commandEncoder29.beginComputePass(); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], sampleCount: 1, depthReadOnly: true}); |
| try { |
| computePassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer19, 'uint32', 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup5, [0]); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| let pipeline4 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| let buffer52 = device0.createBuffer({size: 24, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let textureView47 = texture33.createView({}); |
| try { |
| computePassEncoder11.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer9, 'uint16', 16, 30); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup3, new Uint32Array(550), 39, 1); |
| } catch {} |
| let imageData3 = new ImageData(192, 80); |
| try { |
| adapter0.label = '\u{1fe34}\u013e\ue1e5\u1dfd\u6b63\ue15b\u0a40\u40f2\uaa59'; |
| } catch {} |
| let commandEncoder37 = device0.createCommandEncoder({}); |
| let textureView48 = texture38.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer35, 0); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer45}}, |
| {binding: 58, resource: {buffer: buffer21, offset: 0, size: 584}}, |
| {binding: 43, resource: {buffer: buffer35}}, |
| {binding: 3, resource: textureView0}, |
| ], |
| }); |
| let buffer53 = device0.createBuffer({size: 12, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder38 = device0.createCommandEncoder({}); |
| let texture45 = device0.createTexture({ |
| size: [2, 2, 14], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let buffer54 = device0.createBuffer({size: 62, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let textureView49 = texture10.createView({dimension: '2d-array', format: 'r32sint'}); |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 4, new BigInt64Array(10493).map((_, i) => BigInt(i - 8)), 3297, 0); |
| } catch {} |
| let imageData4 = new ImageData(28, 20); |
| let buffer55 = device0.createBuffer({size: 15968, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup12, new Uint32Array(785), 25, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| await gc(); |
| let texture46 = device0.createTexture({ |
| size: [780, 48, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup7, new Uint32Array(190), 6, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer35); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(113400)), 99, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| bindGroup15.label = '\u4d8a\u031d\u75ab\u{1fbd3}\ued14\u18cb\u7471\u{1f6d7}\u0696\u{1fd90}'; |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 0, resource: externalTexture3}, |
| {binding: 1, resource: externalTexture8}, |
| {binding: 138, resource: textureView13}, |
| ], |
| }); |
| let buffer56 = device0.createBuffer({size: 5472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let texture47 = device0.createTexture({ |
| size: [195, 120, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture48 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 3}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup13, new Uint32Array(1220), 588, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer55, 'uint16', 526, 6_888); |
| } catch {} |
| try { |
| computePassEncoder2.insertDebugMarker('\u4c72'); |
| } catch {} |
| document.body.prepend(img2); |
| let offscreenCanvas1 = new OffscreenCanvas(14, 67); |
| let textureView50 = texture47.createView({}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer53, 'uint32', 0, 0); |
| } catch {} |
| let arrayBuffer0 = buffer44.getMappedRange(0, 0); |
| let texture49 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup2); |
| } catch {} |
| let arrayBuffer1 = buffer44.getMappedRange(8, 8); |
| let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu'); |
| let textureView51 = texture49.createView({label: '\u0e04\u0583\u3237\ud779\u03e5\ucd00\u07ec\ua1f4', mipLevelCount: 1, baseArrayLayer: 0}); |
| let textureView52 = texture48.createView({label: '\uccef\ue95a\ueec2\ua19c', mipLevelCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup0, new Uint32Array(2131), 126, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer38, 'uint16', 0, 9); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer19); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup0, new Uint32Array(388), 5, 0); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let textureView53 = texture49.createView({dimension: '2d', aspect: 'all'}); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup14, new Uint32Array(403), 41, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup15, new Uint32Array(5627), 2_568, 1); |
| } catch {} |
| let textureView54 = texture26.createView({}); |
| await gc(); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout3]}); |
| let buffer57 = device0.createBuffer({size: 52, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView55 = texture33.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup10, new Uint32Array(514), 11, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer53, 'uint32', 0, 0); |
| } catch {} |
| try { |
| shaderModule2.label = '\u3c37\ua218\ue173\u{1f6cf}\u22d1\u66f3\u077d\u189c\u0b86\u929e'; |
| } catch {} |
| let textureView56 = texture41.createView({aspect: 'all'}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup10, [0]); |
| } catch {} |
| try { |
| renderPassEncoder6.insertDebugMarker('\u098f'); |
| } catch {} |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let textureView57 = texture16.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder5.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder33.copyBufferToBuffer(buffer0, 24, buffer34, 124, 8); |
| } catch {} |
| let commandEncoder40 = device0.createCommandEncoder(); |
| let texture50 = device0.createTexture({ |
| size: [8, 12, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture51 = device0.createTexture({size: [8, 12, 30], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup0, new Uint32Array(3686), 236, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer1, 'uint32', 88, 45); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer21, size: 144}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 58, resource: {buffer: buffer37, offset: 0}}, |
| {binding: 43, resource: {buffer: buffer35}}, |
| ], |
| }); |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView58 = texture50.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup15, new Uint32Array(4308), 57, 1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer1, 'uint32', 104, 37); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer5); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let texture52 = device0.createTexture({size: [16, 24, 22], format: 'rg8sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup14, new Uint32Array(1817), 133, 1); |
| } catch {} |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer19, 8, 14); |
| } catch {} |
| try { |
| renderPassEncoder6.insertDebugMarker('\u{1fa9b}'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 11, resource: externalTexture10}, |
| {binding: 216, resource: textureView43}, |
| {binding: 183, resource: textureView40}, |
| {binding: 1, resource: textureView15}, |
| {binding: 243, resource: textureView47}, |
| {binding: 4, resource: sampler7}, |
| {binding: 29, resource: externalTexture8}, |
| {binding: 0, resource: {buffer: buffer21, size: 1160}}, |
| {binding: 7, resource: textureView34}, |
| {binding: 95, resource: {buffer: buffer37}}, |
| {binding: 13, resource: {buffer: buffer37}}, |
| {binding: 362, resource: textureView12}, |
| {binding: 15, resource: {buffer: buffer54, size: 50}}, |
| {binding: 9, resource: sampler2}, |
| ], |
| }); |
| let buffer58 = device0.createBuffer({size: 256, usage: GPUBufferUsage.COPY_DST}); |
| let texture53 = device0.createTexture({size: {width: 16}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(89), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder3.insertDebugMarker('\u6517'); |
| } catch {} |
| let pipeline5 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]}, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 56, |
| attributes: [ |
| {format: 'uint16x2', offset: 4, shaderLocation: 14}, |
| {format: 'uint8x4', offset: 16, shaderLocation: 4}, |
| {format: 'float16x2', offset: 12, shaderLocation: 3}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 13}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint8x2', offset: 6, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'uint32x3', offset: 0, shaderLocation: 0}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 1}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 12}, |
| {format: 'float32x3', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 2}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 132, |
| stepMode: 'instance', |
| attributes: [{format: 'sint32x4', offset: 44, shaderLocation: 5}], |
| }, |
| { |
| arrayStride: 60, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x2', offset: 12, shaderLocation: 11}, |
| {format: 'sint8x2', offset: 58, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'back'}, |
| }); |
| let imageData5 = new ImageData(20, 76); |
| let buffer59 = device0.createBuffer({ |
| size: 88, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({size: [390, 240, 1], format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup15, [0]); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup9); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 632}}, |
| {binding: 6, resource: {buffer: buffer37}}, |
| {binding: 43, resource: {buffer: buffer56}}, |
| {binding: 3, resource: textureView0}, |
| ], |
| }); |
| let texture55 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| mipLevelCount: 8, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg8sint'], |
| }); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer9, 'uint16', 56, 43); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup14, [0]); |
| } catch {} |
| let textureView59 = texture27.createView({baseMipLevel: 0}); |
| let computePassEncoder16 = commandEncoder12.beginComputePass(); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, depthReadOnly: false}); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup18, new Uint32Array(1901), 548, 0); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroup20 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: externalTexture3}, |
| {binding: 0, resource: externalTexture1}, |
| {binding: 138, resource: textureView7}, |
| ], |
| }); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let texture56 = device0.createTexture({ |
| size: [8, 12, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup4, new Uint32Array(254), 9, 1); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 52, new Uint32Array(26384).map((_, i) => i * 2), 764, 0); |
| } catch {} |
| let bindGroup21 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer51}}, |
| {binding: 58, resource: {buffer: buffer21, size: 3560}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 6, resource: {buffer: buffer32}}, |
| ], |
| }); |
| let texture57 = device0.createTexture({size: [97, 60, 39], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 18, 18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(23932)), 495, 0); |
| } catch {} |
| let pipeline6 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2}}); |
| document.body.append(img0); |
| let buffer60 = device0.createBuffer({ |
| size: 196, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture58 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView60 = texture36.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup18, new Uint32Array(5975), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer52, 'uint32', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup11, [0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer43); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1674 */ |
| offset: 1674, |
| bytesPerRow: 12800, |
| buffer: buffer11, |
| }, { |
| texture: texture39, |
| mipLevel: 2, |
| origin: {x: 48, y: 4, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let texture59 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView61 = texture40.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup5, [0]); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup7, new Uint32Array(1463), 58, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer19, 'uint32', 0, 28); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer8, 0); |
| } catch {} |
| try { |
| await buffer46.mapAsync(GPUMapMode.READ, 0, 20); |
| } catch {} |
| await gc(); |
| let buffer61 = device0.createBuffer({size: 164, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture60 = device0.createTexture({ |
| size: [390, 240, 1], |
| sampleCount: 4, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView62 = texture44.createView({mipLevelCount: 1}); |
| let sampler10 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 76.87, |
| lodMaxClamp: 94.98, |
| maxAnisotropy: 7, |
| }); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer1, 'uint32', 120, 8); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup11, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(3, buffer35, 0); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToBuffer(buffer11, 744, buffer60, 24, 4); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout0 = pipeline5.getBindGroupLayout(0); |
| let buffer62 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let texture61 = device0.createTexture({size: {width: 16}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame3}); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup11, new Uint32Array(902), 254, 1); |
| } catch {} |
| let imageData6 = new ImageData(16, 16); |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 1536}}, |
| {binding: 43, resource: {buffer: buffer35}}, |
| {binding: 6, resource: {buffer: buffer34, size: 52}}, |
| {binding: 3, resource: textureView3}, |
| ], |
| }); |
| let textureView63 = texture50.createView({}); |
| let texture62 = device0.createTexture({ |
| size: {width: 1560}, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView64 = texture42.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 0, new Uint32Array(17285).map((_, i) => i * 5), 372, 0); |
| } catch {} |
| let textureView65 = texture31.createView({baseMipLevel: 0}); |
| let texture63 = device0.createTexture({size: [390], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer55, 'uint16', 158, 829); |
| } catch {} |
| await gc(); |
| let buffer63 = device0.createBuffer({size: 356, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer5, 0, 93); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, constants: {}}}); |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt709', transfer: 'smpteSt4281'} }); |
| let buffer64 = device0.createBuffer({size: 192, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder47 = device0.createCommandEncoder({}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer9, 'uint32', 40, 5); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let offscreenCanvas2 = new OffscreenCanvas(32, 158); |
| try { |
| textureView32.label = '\u{1f758}\u{1f657}\uc92a\u07a9\ue063\u{1f7e8}\u03dc\u09f8\u218e\ub62d\u02cf'; |
| } catch {} |
| let textureView66 = texture3.createView({dimension: 'cube', aspect: 'all'}); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer9, 'uint32', 0, 39); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(7, buffer62, 0, 0); |
| } catch {} |
| try { |
| buffer57.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let textureView67 = texture47.createView({}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup19, [0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(4, buffer19, 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer60, 'uint32', 20, 44); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(126).fill(86), /* required buffer size: 126 */ |
| {offset: 126}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext3 = canvas1.getContext('webgpu'); |
| let renderPassEncoder7 = commandEncoder45.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView61, |
| depthSlice: 0, |
| clearValue: { r: 6.806, g: 245.7, b: 41.75, a: 518.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer63, 'uint16', 72, 9); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer35); |
| } catch {} |
| let arrayBuffer2 = buffer46.getMappedRange(0, 4); |
| try { |
| renderBundleEncoder9.pushDebugGroup('\u3510'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 0, new Uint32Array(5717).map((_, i) => i * 3), 1658, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint']}); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup21, [0]); |
| } catch {} |
| let pipeline8 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]}, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x2', offset: 0, shaderLocation: 7}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 4}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 15}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 5}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 2}, |
| {format: 'float16x2', offset: 0, shaderLocation: 10}, |
| {format: 'uint32', offset: 0, shaderLocation: 0}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'sint32', offset: 0, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 9}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 11}, |
| ], |
| }, |
| { |
| arrayStride: 56, |
| attributes: [ |
| {format: 'float32x2', offset: 0, shaderLocation: 13}, |
| {format: 'sint32x2', offset: 12, shaderLocation: 6}, |
| {format: 'uint8x4', offset: 16, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'back', unclippedDepth: true}, |
| }); |
| let imageData7 = new ImageData(176, 140); |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: externalTexture9}, |
| {binding: 138, resource: textureView13}, |
| {binding: 0, resource: externalTexture11}, |
| ], |
| }); |
| let buffer65 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView68 = texture50.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup10, [0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup6, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup5, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer52, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer51.unmap(); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer51}}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 3, resource: textureView3}, |
| {binding: 6, resource: {buffer: buffer20, offset: 0}}, |
| ], |
| }); |
| let buffer66 = device0.createBuffer({ |
| size: 300, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup11, new Uint32Array(7197), 534, 1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup6, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup7, new Uint32Array(4664), 1_740, 1); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView69 = texture33.createView({baseMipLevel: 0}); |
| let texture64 = device0.createTexture({ |
| size: [390, 24, 1], |
| mipLevelCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView70 = texture38.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderBundleEncoder19.setBindGroup(3, bindGroup15, new Uint32Array(797), 49, 1); |
| } catch {} |
| try { |
| commandEncoder10.insertDebugMarker('\ua50a'); |
| } catch {} |
| try { |
| computePassEncoder10.insertDebugMarker('\u2768'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let buffer67 = device0.createBuffer({size: 212, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let textureView71 = texture54.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderPassEncoder5.setVertexBuffer(5, buffer59); |
| } catch {} |
| let texture65 = device0.createTexture({size: [780, 480, 1], mipLevelCount: 1, format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView72 = texture12.createView({mipLevelCount: 1}); |
| let externalTexture14 = device0.importExternalTexture({label: '\u{1fea4}\u9c9a\u3fc7\ue918', source: videoFrame3}); |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup20); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer19, 16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer67, 16, new Uint32Array(12305).map((_, i) => i * 6), 6535, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup13, new Uint32Array(312), 37, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup23, new Uint32Array(696), 263, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer8, 0, 8); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(3, bindGroup4, [0]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(300).fill(95), /* required buffer size: 300 */ |
| {offset: 300}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData8 = new ImageData(8, 52); |
| try { |
| renderBundleEncoder15.setVertexBuffer(1, buffer59, 36); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let gpuCanvasContext4 = offscreenCanvas2.getContext('webgpu'); |
| let bindGroup25 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 904}}, |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 6, resource: {buffer: buffer20}}, |
| {binding: 3, resource: textureView0}, |
| ], |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup22, [0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setBlendConstant({ r: -182.1, g: 993.3, b: -938.0, a: 996.2, }); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup1); |
| } catch {} |
| let texture66 = device0.createTexture({ |
| size: [780, 48, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline8); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule3}}); |
| let autogeneratedBindGroupLayout1 = pipeline7.getBindGroupLayout(0); |
| let buffer68 = device0.createBuffer({size: 160, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let sampler11 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 96.59}); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToBuffer({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 584 */ |
| offset: 584, |
| bytesPerRow: 31744, |
| rowsPerImage: 20, |
| buffer: buffer56, |
| }, {width: 0, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer69 = device0.createBuffer({size: 228, usage: GPUBufferUsage.INDEX}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer53, 'uint32', 0, 9); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer43, 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(1, bindGroup19, [0]); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 176, new DataView(new Uint8Array(45685).map((_, i) => i).buffer), 8242, 912); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer66, 84, new Float32Array(7745).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.932)), 1362, 12); |
| } catch {} |
| let pipeline10 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| document.body.prepend(canvas1); |
| let textureView73 = texture45.createView({dimension: 'cube', format: 'r16sint', arrayLayerCount: 6}); |
| let textureView74 = texture29.createView({}); |
| let sampler12 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 77.71, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup3, new Uint32Array(1964), 1_116, 1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(6, buffer62, 0, 0); |
| } catch {} |
| try { |
| texture40.label = '\u5b16\u0cec\u0fc1\ud7c2\u909a'; |
| } catch {} |
| let buffer70 = device0.createBuffer({size: 512, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let textureView75 = texture8.createView({dimension: '3d', mipLevelCount: 1, baseArrayLayer: 0}); |
| let buffer71 = device0.createBuffer({size: 76, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| let textureView76 = texture30.createView({}); |
| let computePassEncoder17 = commandEncoder15.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 351}}); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer1, 'uint32', 4, 27); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(6, buffer43, 0); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| try { |
| renderBundleEncoder9.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 36, new DataView(new ArrayBuffer(39060)), 1066, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer69, 'uint32', 12, 72); |
| } catch {} |
| try { |
| commandEncoder36.copyBufferToTexture({ |
| /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 846 */ |
| offset: 846, |
| rowsPerImage: 39, |
| buffer: buffer11, |
| }, { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 23, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let texture67 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView77 = texture61.createView({baseArrayLayer: 0}); |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup5, [0]); |
| } catch {} |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| let textureView78 = texture47.createView({aspect: 'all'}); |
| let texture68 = device0.createTexture({ |
| size: [390, 240, 1], |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView79 = texture61.createView({label: '\uf512\ud0d5\ua738\u0909\u07fe'}); |
| let renderPassEncoder8 = commandEncoder7.beginRenderPass({ |
| label: '\u9c74\u475f\u{1f74d}\u6cfc\uc210\u03e8\u3e4e\u0974\u0581\u872b\u5dde', |
| colorAttachments: [{ |
| view: textureView61, |
| depthSlice: 1, |
| clearValue: { r: -407.0, g: -798.6, b: 76.58, a: 478.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(1177), 21, 1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup24, [0]); |
| } catch {} |
| try { |
| commandEncoder38.clearBuffer(buffer38); |
| } catch {} |
| try { |
| commandEncoder33.pushDebugGroup('\u2d26'); |
| } catch {} |
| await gc(); |
| let bindGroup26 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 3, resource: textureView3}, |
| {binding: 58, resource: {buffer: buffer21, size: 1032}}, |
| {binding: 6, resource: {buffer: buffer37}}, |
| {binding: 43, resource: {buffer: buffer64}}, |
| ], |
| }); |
| let texture69 = device0.createTexture({ |
| size: {width: 16}, |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame5, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer60, 'uint32', 56, 45); |
| } catch {} |
| try { |
| commandEncoder33.popDebugGroup(); |
| } catch {} |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let texture70 = device0.createTexture({ |
| size: [32], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder18 = commandEncoder35.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 171, endOfPassWriteIndex: 141}}); |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(49), 1, 1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup9, new Uint32Array(2815), 155, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(2, buffer8, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let texture71 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer43, 8, 4); |
| } catch {} |
| try { |
| computePassEncoder9.insertDebugMarker('\u00c5'); |
| } catch {} |
| let bindGroup27 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 3, resource: textureView0}, |
| {binding: 58, resource: {buffer: buffer21, offset: 1280, size: 904}}, |
| {binding: 43, resource: {buffer: buffer37}}, |
| {binding: 6, resource: {buffer: buffer5}}, |
| ], |
| }); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let textureView80 = texture69.createView({}); |
| let textureView81 = texture55.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 4}); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder4.setVertexBuffer(5, buffer68, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer35); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| renderBundleEncoder15.insertDebugMarker('\u0cf4'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer67, 0, new Float32Array(13188).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.9739)), 682, 0); |
| } catch {} |
| document.body.append(canvas1); |
| let buffer72 = device0.createBuffer({size: 56, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let textureView82 = texture67.createView({arrayLayerCount: 1}); |
| try { |
| commandEncoder49.copyBufferToBuffer(buffer11, 256, buffer10, 48, 44); |
| } catch {} |
| let pipeline11 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| let offscreenCanvas3 = new OffscreenCanvas(58, 236); |
| let texture72 = device0.createTexture({ |
| size: {width: 195, height: 12, depthOrArrayLayers: 1}, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView83 = texture65.createView({dimension: '2d-array', aspect: 'all'}); |
| try { |
| computePassEncoder18.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer53, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer60, 'uint16', 64, 80); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 1_572, new DataView(new Uint8Array(16422).map((_, i) => i).buffer), 207, 3900); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 12, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 42, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| let img3 = await imageWithData(69, 17, '#10101010', '#20202020'); |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} }); |
| let autogeneratedBindGroupLayout2 = pipeline9.getBindGroupLayout(0); |
| let buffer73 = device0.createBuffer({ |
| size: 52, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let texture73 = device0.createTexture({ |
| size: [195], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView84 = texture6.createView({dimension: '2d-array', format: 'r16sint', mipLevelCount: 1}); |
| try { |
| commandEncoder47.copyTextureToBuffer({ |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 93, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 832 widthInBlocks: 52 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 32 */ |
| offset: 32, |
| bytesPerRow: 20480, |
| buffer: buffer22, |
| }, {width: 52, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 32, new DataView(new ArrayBuffer(8300)), 125, 0); |
| } catch {} |
| let pipeline12 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{ |
| format: 'rg8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule3, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 484, shaderLocation: 11}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'snorm8x4', offset: 20, shaderLocation: 0}, |
| {format: 'unorm10-10-10-2', offset: 372, shaderLocation: 1}, |
| {format: 'unorm16x4', offset: 20, shaderLocation: 5}, |
| {format: 'snorm8x4', offset: 64, shaderLocation: 13}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 10}, |
| {format: 'sint8x4', offset: 120, shaderLocation: 4}, |
| {format: 'float16x2', offset: 516, shaderLocation: 6}, |
| {format: 'sint32', offset: 8, shaderLocation: 14}, |
| {format: 'sint32x3', offset: 108, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 68, shaderLocation: 2}, |
| {format: 'snorm16x4', offset: 184, shaderLocation: 8}, |
| {format: 'snorm8x4', offset: 184, shaderLocation: 7}, |
| {format: 'uint16x4', offset: 52, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 696, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list'}, |
| }); |
| let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu'); |
| try { |
| await promise8; |
| } catch {} |
| let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0); |
| let bindGroup28 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer21, size: 1468}}, |
| {binding: 7, resource: textureView65}, |
| {binding: 1, resource: textureView49}, |
| {binding: 216, resource: textureView43}, |
| {binding: 243, resource: textureView37}, |
| {binding: 11, resource: externalTexture13}, |
| {binding: 29, resource: externalTexture13}, |
| {binding: 13, resource: {buffer: buffer66}}, |
| {binding: 183, resource: textureView24}, |
| {binding: 15, resource: {buffer: buffer54, size: 49}}, |
| {binding: 362, resource: textureView57}, |
| {binding: 9, resource: sampler10}, |
| {binding: 4, resource: sampler10}, |
| {binding: 95, resource: {buffer: buffer56, offset: 256}}, |
| ], |
| }); |
| let textureView85 = texture71.createView({arrayLayerCount: 3}); |
| let textureView86 = texture23.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup18, []); |
| } catch {} |
| let arrayBuffer3 = buffer44.getMappedRange(16, 0); |
| try { |
| device0.queue.writeBuffer(buffer56, 1_392, new Float32Array(55832).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4429)), 912, 148); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let textureView87 = texture72.createView({}); |
| let renderPassEncoder9 = commandEncoder39.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView61, |
| depthSlice: 0, |
| clearValue: { r: -903.1, g: 892.6, b: 197.6, a: -36.82, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler13 = device0.createSampler({ |
| label: '\u8f04\u{1fb77}\u{1ff25}\u{1f691}\u0449', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.49, |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer60, 'uint16', 74, 1); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(2, buffer43, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup16, []); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(246).fill(72), /* required buffer size: 246 */ |
| {offset: 246, bytesPerRow: 16}, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas3, |
| origin: { x: 5, y: 29 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 195, y: 24, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView13}, |
| {binding: 0, resource: externalTexture3}, |
| {binding: 1, resource: externalTexture3}, |
| ], |
| }); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let textureView88 = texture73.createView({baseArrayLayer: 0}); |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer43, 0, buffer7, 0, 8); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer69, 'uint16', 6, 8); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let computePassEncoder19 = commandEncoder14.beginComputePass(); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout4 = pipeline7.getBindGroupLayout(0); |
| let buffer74 = device0.createBuffer({size: 88, usage: GPUBufferUsage.INDEX}); |
| let texture74 = device0.createTexture({ |
| size: [780, 480, 10], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg8sint'], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup5, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup11, new Uint32Array(443), 33, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.insertDebugMarker('\u{1f745}'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let texture75 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 38}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder10 = commandEncoder41.beginRenderPass({ |
| colorAttachments: [{view: textureView61, depthSlice: 1, loadOp: 'clear', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 108}, |
| maxDrawCount: 36970143, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup10, new Uint32Array(885), 271, 1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer19, 'uint16', 2, 15); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline1); |
| } catch {} |
| let textureView89 = texture54.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup17, new Uint32Array(1424), 3, 1); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder2.label = '\u04aa\u0e50\ud3f0\u{1f7aa}\u1f05'; |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToBuffer({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 2, y: 4, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1332 */ |
| offset: 1332, |
| bytesPerRow: 49664, |
| buffer: buffer56, |
| }, {width: 3, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder17.insertDebugMarker('\u{1fb3c}'); |
| } catch {} |
| let buffer75 = device0.createBuffer({size: 340, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let textureView90 = texture72.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let texture76 = device0.createTexture({size: [1560, 96, 1], format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| let texture77 = gpuCanvasContext2.getCurrentTexture(); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup14, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(0, buffer59, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 16, new Float32Array(9975).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.277)), 2572, 12); |
| } catch {} |
| let pipeline13 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 508, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x2', offset: 208, shaderLocation: 8}, |
| {format: 'uint32x2', offset: 24, shaderLocation: 0}, |
| {format: 'unorm16x2', offset: 60, shaderLocation: 7}, |
| {format: 'uint8x4', offset: 228, shaderLocation: 9}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 1}, |
| {format: 'snorm16x2', offset: 128, shaderLocation: 3}, |
| {format: 'snorm16x4', offset: 300, shaderLocation: 4}, |
| {format: 'snorm16x4', offset: 68, shaderLocation: 2}, |
| {format: 'unorm8x2', offset: 58, shaderLocation: 14}, |
| {format: 'uint32x3', offset: 24, shaderLocation: 6}, |
| ], |
| }, |
| {arrayStride: 4, attributes: [{format: 'snorm8x4', offset: 0, shaderLocation: 12}]}, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'back'}, |
| }); |
| let textureView91 = texture47.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup14, new Uint32Array(992), 433, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup6, new Uint32Array(1392), 350, 1); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer74, 'uint32', 28, 11); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'iec6196624'} }); |
| let textureView92 = texture41.createView({format: 'r16sint'}); |
| try { |
| renderPassEncoder6.setVertexBuffer(0, buffer35, 8, 39); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer5); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToBuffer({ |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 758, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 352 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1744 */ |
| offset: 1744, |
| bytesPerRow: 49408, |
| buffer: buffer11, |
| }, {width: 22, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder15.insertDebugMarker('\u5d4f'); |
| } catch {} |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| let textureView93 = texture45.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup18, new Uint32Array(3395), 1_489, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer9, 'uint32', 40, 37); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(4, buffer68, 64, 4); |
| } catch {} |
| try { |
| commandEncoder52.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1492 */ |
| offset: 1492, |
| buffer: buffer11, |
| }, { |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer76 = device0.createBuffer({size: 204, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer5, 0, 64); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup13, new Uint32Array(1498), 79, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| texture63.label = '\u2f93\u{1fdb5}\ua6e4\ud7ab\ub2a0'; |
| } catch {} |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder10.setVertexBuffer(3, buffer62, 0); |
| } catch {} |
| try { |
| commandEncoder36.resolveQuerySet(querySet0, 98, 0, buffer71, 0); |
| } catch {} |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let textureView94 = texture33.createView({mipLevelCount: 1}); |
| let renderPassEncoder11 = commandEncoder54.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView61, |
| depthSlice: 1, |
| clearValue: { r: -18.34, g: -399.5, b: -427.2, a: 416.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 249163384, |
| }); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(140); }; |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer73}}], |
| }); |
| let textureView95 = texture51.createView({baseArrayLayer: 0, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup26, new Uint32Array(13), 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer59, 0, 0); |
| } catch {} |
| try { |
| buffer71.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 0, new Float16Array(18500).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.699)), 5443, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 46, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(35).fill(27), /* required buffer size: 35 */ |
| {offset: 35}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let texture78 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 31}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg8sint'], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(5, buffer19, 0, 25); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup3, new Uint32Array(3104), 326, 1); |
| } catch {} |
| try { |
| buffer62.unmap(); |
| } catch {} |
| let imageData9 = new ImageData(64, 52); |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt470m', transfer: 'smpteSt4281'} }); |
| try { |
| adapter0.label = '\u7416\u{1f709}\u8e8d\u086a\uf4ea\u622d\u0011\u0f20\uda3e\u03cb'; |
| } catch {} |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], sampleCount: 1, depthReadOnly: true}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup4, [0]); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(4, buffer5, 0, 21); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(2, buffer68, 0, 24); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder31.insertDebugMarker('\u8655'); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer19, 'uint32', 8, 23); |
| } catch {} |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let textureView96 = texture78.createView({dimension: '3d', baseMipLevel: 0}); |
| let renderPassEncoder12 = commandEncoder52.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView96, |
| depthSlice: 14, |
| clearValue: { r: 484.2, g: 192.0, b: -887.8, a: -33.41, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 237}, |
| }); |
| let sampler14 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 92.48}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup9, []); |
| } catch {} |
| let videoFrame11 = videoFrame1.clone(); |
| let textureView97 = texture67.createView({aspect: 'all'}); |
| let textureView98 = texture33.createView({aspect: 'all'}); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer69, 'uint32', 44, 3); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup16, new Uint32Array(927), 178, 0); |
| } catch {} |
| try { |
| await buffer67.mapAsync(GPUMapMode.READ, 56, 20); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 152, new Uint32Array(2761).map((_, i) => i * 5), 1450, 44); |
| } catch {} |
| document.body.prepend(canvas1); |
| let textureView99 = texture65.createView({}); |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer68); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(1, buffer62, 0, 2); |
| } catch {} |
| let buffer77 = device0.createBuffer({size: 176, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let textureView100 = texture67.createView({}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup15, [0]); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer35, 8, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 92, new Float32Array(1843).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8940)), 96, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 7, y: 19, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer78 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer38, 'uint16', 40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup30, new Uint32Array(596), 209, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer71, 0, 10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 4, new BigInt64Array(622).map((_, i) => BigInt(i - 0)), 206, 0); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer73}}], |
| }); |
| let textureView101 = texture41.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer59); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(3, bindGroup7, new Uint32Array(811), 46, 1); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer63, 'uint16', 76, 40); |
| } catch {} |
| try { |
| buffer78.unmap(); |
| } catch {} |
| let bindGroup33 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 58, resource: {buffer: buffer21, size: 1036}}, {binding: 6, resource: {buffer: buffer60}}], |
| }); |
| try { |
| renderPassEncoder6.setStencilReference(0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer63, 'uint16', 114, 11); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 84 widthInBlocks: 42 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 850 */ |
| offset: 850, |
| bytesPerRow: 11776, |
| buffer: buffer11, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 31, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 42, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer78, 0, new Float32Array(9854).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.463)), 239, 0); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer4}}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 6, resource: {buffer: buffer20, offset: 0}}, |
| ], |
| }); |
| let commandEncoder63 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer8, 20); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fb0f}\u{1fed8}\u1334\u08b9\uab64\u{1f788}\u{1fc54}\u{1f712}'; |
| } catch {} |
| let autogeneratedBindGroupLayout5 = pipeline0.getBindGroupLayout(1); |
| let sampler15 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 79.10, maxAnisotropy: 1}); |
| try { |
| renderPassEncoder12.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup32, new Uint32Array(178), 7, 0); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 0 */ |
| offset: 0, |
| rowsPerImage: 265, |
| buffer: buffer8, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup35 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 1, resource: externalTexture1}, {binding: 3, resource: textureView3}], |
| }); |
| let textureView102 = texture40.createView({baseMipLevel: 0}); |
| let computePassEncoder20 = commandEncoder48.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 356}}); |
| let sampler16 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 73.78, |
| maxAnisotropy: 5, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup7, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer19, 0, 5); |
| } catch {} |
| let bindGroup36 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer22}}, |
| {binding: 43, resource: {buffer: buffer51}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 58, resource: {buffer: buffer21, size: 800}}, |
| ], |
| }); |
| let buffer79 = device0.createBuffer({size: 132, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 16, 67); |
| } catch {} |
| document.body.prepend(img2); |
| let texture79 = device0.createTexture({ |
| size: [16, 24, 4], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup25, new Uint32Array(977), 102, 1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(2, buffer68, 0); |
| } catch {} |
| try { |
| commandEncoder44.clearBuffer(buffer2, 8, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer75, 8, new Uint32Array(9483).map((_, i) => i * 1), 629, 4); |
| } catch {} |
| let buffer80 = device0.createBuffer({ |
| size: 108, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let textureView103 = texture79.createView({}); |
| try { |
| renderPassEncoder11.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer65, 'uint32', 8, 2); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let imageData10 = new ImageData(72, 8); |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 12, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 81, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 86, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 106, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 125, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 148, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 152, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 166, |
| visibility: 0, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 220, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 251, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer81 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let textureView104 = texture50.createView({dimension: '2d-array'}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame8}); |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(5, 0, 1, -1_939_803_733); |
| } catch {} |
| let bindGroup37 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 1, resource: externalTexture3}, {binding: 3, resource: textureView17}], |
| }); |
| let buffer82 = device0.createBuffer({ |
| size: 120, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture80 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 2}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup36, [0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 76, new Float32Array(27144).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.332)), 9499, 0); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| var<workgroup> vw8: vec2h; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T6 { |
| @size(160) f0: f16, |
| f1: array<atomic<u32>>, |
| } |
| |
| @id(5373) override override7: bool; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput28 { |
| @location(9) location_9: f16, |
| } |
| |
| struct T2 { |
| f0: array<vec2f>, |
| } |
| |
| struct VertexInput29 { |
| @location(15) location_15: vec4i, |
| @location(13) @interpolate(linear, either) location_13: vec2h, |
| } |
| |
| override override5: f16 = 12869.2; |
| |
| struct VertexOutput5 { |
| @location(3) location_3: vec4u, |
| @location(9) location_9: vec4i, |
| @location(14) location_14: vec4i, |
| @location(2) location_2: u32, |
| @location(4) @interpolate(flat, center) location_4: vec2i, |
| @invariant @builtin(position) position: vec4f, |
| @location(0) location_0: vec4i, |
| @location(8) location_8: f32, |
| @location(13) location_13: u32, |
| @location(11) @interpolate(flat, sample) location_11: i32, |
| @location(6) @interpolate(flat) location_6: vec4h, |
| @location(1) location_1: f32, |
| @location(5) @interpolate(flat, centroid) location_5: f16, |
| @location(10) @interpolate(flat, center) location_10: vec4u, |
| } |
| |
| @group(2) @binding(711) var sam3: sampler; |
| |
| struct T0 { |
| @align(8) f0: array<vec2<bool>>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(0) @binding(1) var et7: texture_external; |
| |
| @group(0) @binding(138) var st6: texture_storage_2d<r32uint, read_write>; |
| |
| struct T4 { |
| @size(352) f0: vec2<bool>, |
| @size(64) f1: vec4<bool>, |
| } |
| |
| struct T1 { |
| @align(8) f0: array<u32>, |
| } |
| |
| override override9: f32; |
| |
| @group(1) @binding(176) var<storage, read_write> buffer84: array<array<array<VertexInput28, 5>, 1>, 160>; |
| |
| struct VertexOutput4 { |
| @location(4) location_4: f16, |
| @location(14) location_14: i32, |
| @location(10) location_10: vec2u, |
| @location(8) location_8: i32, |
| @location(11) location_11: vec4h, |
| @location(7) @interpolate(linear) location_7: f16, |
| @location(5) @interpolate(flat, center) location_5: vec4u, |
| @builtin(position) position: vec4f, |
| @location(12) @interpolate(flat, centroid) location_12: vec2u, |
| @location(1) location_1: i32, |
| @location(9) @interpolate(perspective, sample) location_9: vec2h, |
| @location(3) @interpolate(flat, sample) location_3: vec2i, |
| @location(13) @interpolate(flat, either) location_13: i32, |
| } |
| |
| struct VertexInput25 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| @id(60452) override override6: bool; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw6: atomic<u32>; |
| |
| struct VertexInput22 { |
| @location(0) @interpolate(flat, sample) location_0: vec4u, |
| @location(10) @interpolate(flat, first) location_10: u32, |
| @location(13) @interpolate(flat) location_13: u32, |
| } |
| |
| var<workgroup> vw7: array<vec2<bool>, 4>; |
| |
| @group(1) @binding(557) var et8: texture_external; |
| |
| @id(45504) override override8: bool; |
| |
| struct VertexInput27 { |
| @location(6) @interpolate(flat) location_6: vec2h, |
| } |
| |
| struct VertexInput30 { |
| @location(4) @interpolate(perspective, center) location_4: vec4h, |
| } |
| |
| @group(2) @binding(47) var tex6: texture_2d<f32>; |
| |
| @group(2) @binding(241) var<storage, read_write> buffer86: array<array<array<array<array<array<VertexInput28, 1>, 13>, 1>, 8>, 2>>; |
| |
| struct VertexInput24 { |
| @location(12) @interpolate(linear, first) location_12: f32, |
| } |
| |
| struct T5 { |
| @size(1536) f0: vec4<bool>, |
| @size(384) f1: array<vec2<bool>, 24>, |
| } |
| |
| struct VertexInput23 { |
| @location(7) @interpolate(flat) location_7: u32, |
| @location(2) @interpolate(flat) location_2: u32, |
| @location(4) @interpolate(flat, centroid) location_4: vec2i, |
| } |
| |
| struct T3 { |
| @align(32) f0: array<u32>, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| @group(1) @binding(0) var<storage, read_write> buffer83: array<VertexInput23>; |
| |
| struct VertexInput26 { |
| @location(15) @interpolate(linear, sample) location_15: vec4h, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* used global variables: et7, et8, sam3, tex6 */ |
| @vertex |
| fn vertex5(a0: VertexInput22, @location(14) location_14: vec4i, a2: VertexInput23, a3: VertexInput24, @location(11) location_11: vec2h, @location(9) location_9: vec2h, a6: VertexInput25, @location(3) @interpolate(flat, first) location_3: vec4u, @builtin(instance_index) instance_index: u32, @location(5) location_5: vec2h, a10: VertexInput26, @location(1) @interpolate(linear) location_1: f16, a12: VertexInput27, @location(8) @interpolate(perspective, first) location_8: f16) -> VertexOutput4 { |
| var out: VertexOutput4; |
| out.location_8 = vec4i(textureGather(520051819 % 4, tex6, sam3, vec2f(unconst_f32(0.00608), unconst_f32(0.3332)), clamp(vec2i(205989543, -688854755), vec2i(-8), vec2i(7))).yxww.wzzz.rgrb.wwwx)[1]; |
| let vf54: vec4f = textureSampleBaseClampToEdge(et8, sam3, vec2f(unconst_f32(0.6956e-5), unconst_f32(0.4037e-39))); |
| out.location_3 *= vec2i(bitcast<i32>(a3.location_12)); |
| var vf55: vec2h = location_11; |
| while bool(out.location_9[1]) { |
| out.location_12 -= vec2u(abs(textureDimensions(et7)[0])); |
| out.location_8 |= out.location_3[unconst_u32(1574242734)]; |
| for (var it3=out.location_5[unconst_u32(1125836571)]; it3<(a0.location_10 & 0xfff); it3++) { |
| var vf56: u32 = a2.location_7; |
| break; |
| } |
| out = VertexOutput4(f16(a0.location_13), bitcast<i32>(a0.location_13), vec2u(a0.location_13), i32(a0.location_13), vec4h(f16(a0.location_13)), f16(a0.location_13), unpack4xU8(a0.location_13), unpack4x8snorm(a0.location_13), vec2u(a0.location_13), bitcast<i32>(a0.location_13), bitcast<vec2h>(a0.location_13), vec2i(bitcast<i32>(a0.location_13)), i32(a0.location_13)); |
| let ptr20: ptr<function, vec2u> = &out.location_10; |
| out.location_7 = vec2h(out.location_10.yx.yx)[1]; |
| return out; |
| _ = et7; |
| } |
| out.position = unpack4x8unorm(location_3[unconst_u32(1294634619)]); |
| out = VertexOutput4(f16(a0.location_13), i32(a0.location_13), vec2u(a0.location_13), i32(a0.location_13), vec4h(f16(a0.location_13)), f16(a0.location_13), unpack4xU8(a0.location_13), unpack4x8unorm(a0.location_13), vec2u(a0.location_13), i32(a0.location_13), bitcast<vec2h>(a0.location_13), vec2i(i32(a0.location_13)), i32(a0.location_13)); |
| out.location_4 = out.location_7; |
| out.location_10 = vec2u(a12.location_6.yx); |
| out.location_12 = vec2u(a0.location_10); |
| return out; |
| _ = tex6; |
| _ = et8; |
| _ = et7; |
| _ = sam3; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex6(a0: VertexInput28, @location(12) @interpolate(flat, center) location_12: u32, a2: VertexInput29, a3: VertexInput30) -> VertexOutput5 { |
| var out: VertexOutput5; |
| var vf57: vec2f = step(vec2f(unconst_f32(0.01713e-1), unconst_f32(-0.07758)), vec2f(unconst_f32(0.01395), unconst_f32(0.4488e-17))); |
| let vf58: f16 = determinant(mat3x3h(unconst_f16(657.7), unconst_f16(1764.9), unconst_f16(11391.3), unconst_f16(7314.1), unconst_f16(11537.9), unconst_f16(3050.1), unconst_f16(2642.9), unconst_f16(71.42), unconst_f16(4712.7))); |
| return out; |
| } |
| |
| /* used global variables: buffer84, buffer86, st6 */ |
| @fragment |
| fn fragment5() -> @location(200) @interpolate(perspective, either) vec2i { |
| var out: vec2i; |
| let ptr21: ptr<storage, array<VertexInput28, 5>, read_write> = &buffer84[159][unconst_u32(104075828)]; |
| textureStore(st6, vec2i(unconst_i32(481266918), unconst_i32(197546800)), vec4u(vec4u(unconst_u32(88221229), unconst_u32(246347021), unconst_u32(1094595735), unconst_u32(262094236)))); |
| while bool((*&buffer84)[unconst_u32(1125329435)][unconst_u32(451870526)][unconst_u32(255206263)].location_9) { |
| let ptr22: ptr<storage, f16, read_write> = &(*&buffer86)[unconst_u32(301394400)][1][unconst_u32(1478187037)][0][12][unconst_u32(1329135521)].location_9; |
| let ptr23: ptr<storage, array<VertexInput28, 1>, read_write> = &(*&buffer86)[arrayLength(&(*&buffer86))][1][7][unconst_u32(1138626825)][12]; |
| while bool(buffer86[u32(buffer86[arrayLength(&buffer86)][1][7][0][12][0].location_9)][unconst_u32(2319867523)][unconst_u32(610593127)][0][12][unconst_u32(212665267)].location_9) { |
| let ptr24: ptr<storage, array<array<array<VertexInput28, 1>, 13>, 1>, read_write> = &buffer86[unconst_u32(8469300)][1][unconst_u32(945370215)]; |
| let ptr25: ptr<storage, VertexInput28, read_write> = &buffer86[arrayLength(&buffer86)][1][7][0][unconst_u32(340249015)][unconst_u32(255795274)]; |
| return out; |
| _ = buffer86; |
| } |
| _ = buffer86; |
| } |
| let ptr26: ptr<storage, f16, read_write> = &buffer84[unconst_u32(414464026)][0][4].location_9; |
| let ptr27: ptr<storage, VertexInput28, read_write> = &(*&buffer86)[arrayLength(&(*&buffer86))][unconst_u32(388950301)][unconst_u32(68184366)][0][12][0]; |
| return out; |
| _ = buffer86; |
| _ = buffer84; |
| _ = st6; |
| } |
| |
| /* used global variables: buffer83, buffer84 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute5(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) { |
| buffer83[unconst_u32(1356676135)].location_7 ^= u32(buffer84[unconst_u32(1516344082)][0][4].location_9); |
| let ptr28: ptr<workgroup, array<vec2<bool>, 4>> = &vw7; |
| let vf59: bool = override7; |
| let vf60: f32 = determinant(mat3x3f(f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5), f32(override5))); |
| vw8 += vec2h(buffer84[unconst_u32(404786200)][unconst_u32(1462778086)][4].location_9); |
| _ = override7; |
| _ = override5; |
| _ = buffer83; |
| _ = buffer84; |
| }`, |
| }); |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView13}, |
| {binding: 0, resource: externalTexture6}, |
| {binding: 1, resource: externalTexture4}, |
| ], |
| }); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let textureView105 = texture80.createView({}); |
| let texture81 = device0.createTexture({size: [780, 48, 1], mipLevelCount: 2, format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderBundleEncoder5.drawIndexed(2, 0, 2, -1_553_004_132); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer43, 0, 7); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| document.body.append(canvas0); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 57.41, |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderBundleEncoder5.drawIndirect(buffer35, 20); |
| } catch {} |
| try { |
| buffer60.unmap(); |
| } catch {} |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let texture82 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 68}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView106 = texture12.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer55, 'uint32', 7_744, 1_165); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer77); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(5, buffer8, 56, 0); |
| } catch {} |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup10, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer39, 80); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(0, buffer62, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.insertDebugMarker('\u966e'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 108, new DataView(new Uint8Array(1925).map((_, i) => i).buffer), 688, 32); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 2, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(97).fill(89), /* required buffer size: 97 */ |
| {offset: 97}, {width: 111, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup33); |
| } catch {} |
| try { |
| commandEncoder34.clearBuffer(buffer67); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let canvas2 = document.createElement('canvas'); |
| let buffer89 = device0.createBuffer({size: 381, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let textureView107 = texture52.createView({dimension: '2d', baseArrayLayer: 5}); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup5, new Uint32Array(977), 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(290, 0, 96_329_683); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(2, 0, 0, 63_099_126); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer65, 'uint16', 6, 6); |
| } catch {} |
| let buffer90 = device0.createBuffer({ |
| size: 477, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView108 = texture47.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(4, buffer43, 8, 1); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 67, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'bt2020_10bit'} }); |
| let videoFrame13 = videoFrame10.clone(); |
| let textureView109 = texture15.createView({dimension: '2d-array', aspect: 'all', format: 'r16sint', mipLevelCount: 1}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup11, [0]); |
| } catch {} |
| let gpuCanvasContext6 = canvas2.getContext('webgpu'); |
| document.body.append(canvas0); |
| try { |
| globalThis.someLabel = externalTexture12.label; |
| } catch {} |
| let buffer91 = device0.createBuffer({size: 12632, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder70 = device0.createCommandEncoder(); |
| let texture83 = gpuCanvasContext1.getCurrentTexture(); |
| let renderPassEncoder13 = commandEncoder32.beginRenderPass({ |
| label: '\u0305\u0a15\uf144', |
| colorAttachments: [{ |
| view: textureView61, |
| depthSlice: 0, |
| clearValue: { r: -676.7, g: 267.3, b: -323.1, a: -673.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet0}, |
| }); |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup36, new Uint32Array(106), 31, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer89); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer38, 'uint16', 4, 27); |
| } catch {} |
| let pipeline14 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, entryPoint: 'fragment1', targets: [{format: 'r16sint'}]}, |
| vertex: { |
| module: shaderModule2, |
| buffers: [ |
| { |
| arrayStride: 40, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 0, shaderLocation: 6}, |
| {format: 'uint8x2', offset: 8, shaderLocation: 14}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 2}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let img4 = await imageWithData(158, 25, '#10101010', '#20202020'); |
| let bindGroup39 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 6, resource: {buffer: buffer37}}, {binding: 58, resource: {buffer: buffer37}}], |
| }); |
| let textureView110 = texture34.createView({}); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup30, new Uint32Array(1988), 714, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer38, 'uint16', 42, 1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer55, 'uint32', 1_112, 111); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline14); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let renderBundle0 = renderBundleEncoder5.finish({}); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder8.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer9, 'uint16', 24, 3); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer52, 'uint32', 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 8, new Uint32Array(8529).map((_, i) => i * 7), 175, 8); |
| } catch {} |
| let imageData11 = new ImageData(48, 12); |
| let textureView111 = texture78.createView({format: 'rg8sint'}); |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup22, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(3, buffer59, 16); |
| } catch {} |
| try { |
| commandEncoder64.pushDebugGroup('\u{1f685}'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 0, new Float32Array(16410).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.256)), 303, 0); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let buffer92 = device0.createBuffer({size: 160, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder71 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer68, 116, 2); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(4, buffer19, 28, 8); |
| } catch {} |
| try { |
| commandEncoder36.resolveQuerySet(querySet0, 5, 0, buffer8, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| adapter0.label = '\u{1f990}\uae32\ue375\u93ba'; |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer77, 0, 36); |
| } catch {} |
| try { |
| commandEncoder57.resolveQuerySet(querySet0, 3, 0, buffer36, 0); |
| } catch {} |
| let imageData12 = new ImageData(24, 8); |
| let buffer93 = device0.createBuffer({size: 132, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let computePassEncoder21 = commandEncoder55.beginComputePass(); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup0, new Uint32Array(506), 121, 0); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup39, new Uint32Array(2108), 656, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer35, 24, 17); |
| } catch {} |
| let arrayBuffer4 = buffer44.getMappedRange(24, 0); |
| try { |
| commandEncoder64.popDebugGroup(); |
| } catch {} |
| let buffer94 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| try { |
| renderBundleEncoder8.setVertexBuffer(2, buffer35); |
| } catch {} |
| try { |
| commandEncoder72.resolveQuerySet(querySet0, 10, 11, buffer76, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 46, y: 11, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(77).fill(156), /* required buffer size: 77 */ |
| {offset: 77, bytesPerRow: 153}, {width: 22, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture84 = device0.createTexture({ |
| size: [390, 240, 19], |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture85 = device0.createTexture({ |
| size: [8, 12, 7], |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer93, 'uint16', 36, 7); |
| } catch {} |
| await gc(); |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let texture86 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 2}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView112 = texture34.createView({aspect: 'all', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder6.setStencilReference(1486); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer38, 'uint32', 0, 5); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let gpuCanvasContext7 = canvas3.getContext('webgpu'); |
| await gc(); |
| try { |
| globalThis.someLabel = commandEncoder4.label; |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 10, resource: {buffer: buffer34}}]}); |
| let buffer95 = device0.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC}); |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer38, 'uint16', 42, 4); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup11, new Uint32Array(174), 2, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer19, 'uint32', 32, 17); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer59, 0, 12); |
| } catch {} |
| let pipeline15 = await device0.createComputePipelineAsync({label: '\uf277\u0aa3', layout: 'auto', compute: {module: shaderModule3, constants: {}}}); |
| let offscreenCanvas4 = new OffscreenCanvas(60, 338); |
| let texture87 = device0.createTexture({ |
| size: {width: 16, height: 24, depthOrArrayLayers: 42}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView113 = texture32.createView({dimension: '1d', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer43, 4, 21); |
| } catch {} |
| try { |
| commandEncoder70.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 404 */ |
| offset: 404, |
| bytesPerRow: 5120, |
| buffer: buffer11, |
| }, { |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 4, new BigInt64Array(34030).map((_, i) => BigInt(i - 8)), 6512, 0); |
| } catch {} |
| let buffer96 = device0.createBuffer({size: 400, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer35); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer1, 'uint32', 8, 24); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer19); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer63, 'uint16', 104, 17); |
| } catch {} |
| document.body.append(canvas2); |
| let commandEncoder74 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer65, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup35, new Uint32Array(2882), 44, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline14); |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| struct VertexOutput6 { |
| @location(8) location_8: f16, |
| @location(13) location_13: f32, |
| @location(5) @interpolate(flat, either) location_5: f32, |
| @builtin(position) position: vec4f, |
| @location(6) @interpolate(flat, first) location_6: f16, |
| @location(4) location_4: i32, |
| @location(1) location_1: vec2h, |
| @location(2) @interpolate(flat, center) location_2: i32, |
| @location(10) location_10: i32, |
| @location(9) location_9: vec4f, |
| } |
| |
| override override15: f32; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| override override20 = -90022044; |
| |
| struct VertexInput32 { |
| @location(13) location_13: f32, |
| } |
| |
| struct T3 { |
| @size(16) f0: T2, |
| } |
| |
| @id(37735) override override11 = 0.05001e0; |
| |
| @id(40391) override override12 = -0.6008e-11; |
| |
| override override18: f16; |
| |
| struct VertexInput31 { |
| @location(4) @interpolate(perspective, center) location_4: vec2h, |
| @location(5) @interpolate(flat) location_5: vec2h, |
| } |
| |
| @id(61507) override override10 = true; |
| |
| struct FragmentInput8 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| struct VertexInput33 { |
| @location(3) @interpolate(flat, center) location_3: vec4u, |
| } |
| |
| struct VertexInput35 { |
| @location(11) @interpolate(flat, centroid) location_11: u32, |
| } |
| |
| @id(23510) override override17 = -828380792; |
| |
| override override13: f32; |
| |
| @group(0) @binding(58) var<storage, read_write> buffer99: array<array<array<f16, 3>, 96>>; |
| |
| @id(43184) override override19 = 0.1538; |
| |
| struct VertexInput36 { |
| @location(10) location_10: vec2h, |
| } |
| |
| struct FragmentInput7 { |
| @location(3) @interpolate(linear, sample) location_3: vec2f, |
| @location(7) @interpolate(flat, sample) location_7: vec2f, |
| } |
| |
| struct FragmentOutput3 { |
| @location(0) @interpolate(flat) location_0: vec2i, |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| struct T2 { |
| f0: vec2u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(27232) override override16: bool; |
| |
| struct ComputeInput6 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct T0 { |
| @size(104) f0: array<array<vec4f, 3>, 2>, |
| } |
| |
| struct T1 { |
| @align(32) @size(704) f0: vec4f, |
| @align(32) @size(256) f1: T0, |
| @align(32) @size(96) f2: vec2i, |
| @size(32) f3: bool, |
| @align(32) @size(128) f4: T0, |
| @size(96) f5: array<u32, 1>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<function, f16>) -> array<vec4h, 1> { |
| var out: array<vec4h, 1>; |
| var vf61: f16 = out[unconst_u32(358505797)][unconst_u32(2769330252)]; |
| (*a0) = f16(override20); |
| let vf62: f16 = override18; |
| let vf63: vec3f = ldexp(vec3f(unconst_f32(0.08511), unconst_f32(0.06441e2), unconst_f32(0.2193e-14)), vec3i(unconst_i32(201605753), unconst_i32(294243036), unconst_i32(237877818))); |
| return out; |
| _ = override20; |
| _ = override18; |
| } |
| |
| struct T4 { |
| f0: array<vec2h>, |
| } |
| |
| struct FragmentInput9 { |
| @location(1) location_1: vec4h, |
| } |
| |
| struct VertexInput34 { |
| @location(14) @interpolate(linear, first) location_14: vec2f, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| override override14: i32; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex7(@location(12) location_12: f32, a1: VertexInput31, a2: VertexInput32, a3: VertexInput33, @location(0) location_0: vec4f, @location(7) location_7: u32, a6: VertexInput34, @location(15) @interpolate(flat) location_15: vec4i, @location(8) @interpolate(linear, either) location_8: vec2h, a9: VertexInput35, @location(9) location_9: u32, a11: VertexInput36, @location(6) @interpolate(flat, either) location_6: vec4i) -> VertexOutput6 { |
| var out: VertexOutput6; |
| _ = fn0(&out.location_8); |
| let vf64: u32 = a9.location_11; |
| out.location_8 *= f16(vf64); |
| fn0(&out.location_6); |
| let vf65: f32 = location_0[unconst_u32(30055204)]; |
| var vf66 = fn0(&out.location_8); |
| return out; |
| _ = override20; |
| _ = override18; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment6(@location(5) location_5: u32, a1: FragmentInput7, @builtin(sample_mask) sample_mask: u32, a3: FragmentInput8, a4: FragmentInput9) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| return out; |
| } |
| |
| /* used global variables: buffer99 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute6(a0: ComputeInput6) { |
| let ptr29: ptr<storage, array<f16, 3>, read_write> = &buffer99[unconst_u32(309593765)][unconst_u32(457073364)]; |
| buffer99[unconst_u32(669067889)][unconst_u32(2661272868)][unconst_u32(924326631)] *= buffer99[unconst_u32(439496372)][95][2]; |
| let ptr30: ptr<storage, array<array<f16, 3>, 96>, read_write> = &buffer99[unconst_u32(429784834)]; |
| storageBarrier(); |
| workgroupBarrier(); |
| for (var jj44=0u; jj44<5; jj44++) { buffer99[unconst_u32(753062941)][unconst_u32(956432140)][jj44] = buffer99[unconst_u32(1131083076)][unconst_u32(112248195)][2]; } |
| var vf67: vec2u = (vec2u(unconst_u32(424127910), unconst_u32(480718399)) | vec2u(unconst_u32(36627551), unconst_u32(678941131))); |
| _ = buffer99; |
| }`, |
| }); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup7, [0]); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer53, 'uint16'); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup15, new Uint32Array(380), 47, 1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 24, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext8 = offscreenCanvas4.getContext('webgpu'); |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let sampler18 = device0.createSampler({addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder20.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup9, new Uint32Array(4795), 689, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer78, 4, new Uint16Array(11327).map((_, i) => i + 10), 654, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 3, y: 89 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img3); |
| let texture88 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 32}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup32); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(2, 0, 0, 52_783_199); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer55, 1_652); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas2, |
| origin: { x: 8, y: 23 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 207, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let texture89 = device0.createTexture({size: [8, 12, 2], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView114 = texture6.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0}); |
| let renderBundle1 = renderBundleEncoder8.finish({}); |
| let externalTexture23 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup10, [0]); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer71, 28, 8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 0, new Uint32Array(25106).map((_, i) => i * 3), 3065, 0); |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let textureView115 = texture25.createView({baseMipLevel: 2, mipLevelCount: 1}); |
| let textureView116 = texture2.createView({dimension: '2d-array'}); |
| let textureView117 = texture57.createView({}); |
| try { |
| renderBundleEncoder6.setPipeline(pipeline13); |
| } catch {} |
| let imageData13 = new ImageData(108, 28); |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470bg', transfer: 'unspecified'} }); |
| let textureView118 = texture50.createView({}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToTexture({ |
| /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 178 */ |
| offset: 178, |
| bytesPerRow: 69632, |
| buffer: buffer96, |
| }, { |
| texture: texture55, |
| mipLevel: 2, |
| origin: {x: 48, y: 20, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 37, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 28, new Float32Array(2197).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.206)), 227, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let autogeneratedBindGroupLayout6 = pipeline12.getBindGroupLayout(0); |
| let bindGroup41 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 10, resource: {buffer: buffer66}}]}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup12, new Uint32Array(762), 210, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(642); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer65, 'uint32', 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer35, 0, 23); |
| } catch {} |
| let arrayBuffer5 = buffer67.getMappedRange(56, 8); |
| document.body.append(img2); |
| let buffer100 = device0.createBuffer({size: 236, usage: GPUBufferUsage.INDEX}); |
| let textureView119 = texture50.createView({dimension: '2d-array'}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| commandEncoder47.resolveQuerySet(querySet0, 275, 0, buffer8, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 2, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 8, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas2); |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpteRp431', transfer: 'bt709'} }); |
| try { |
| renderPassEncoder10.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup36, new Uint32Array(1772), 149, 1); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(27); }; |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup29); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer60, 'uint32', 32, 25); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 8, new DataView(new Uint8Array(329).map((_, i) => i).buffer), 66, 12); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'gamma22curve'} }); |
| let textureView120 = texture81.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer19, 'uint16', 2); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline5); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 3_320, new Float32Array(2).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.05424))); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas4, |
| origin: { x: 4, y: 20 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 78, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture90 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView121 = texture9.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder23.setVertexBuffer(0, buffer62, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 2_164, new BigInt64Array(5947).map((_, i) => BigInt(i - 9)), 1037, 12); |
| } catch {} |
| let texture91 = device0.createTexture({size: [32], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView122 = texture55.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder15.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup12, new Uint32Array(3319), 107, 0); |
| } catch {} |
| let pipeline16 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x51cf104}, |
| fragment: {module: shaderModule6, constants: {}, targets: [{format: 'r16sint'}]}, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex6', |
| buffers: [ |
| { |
| arrayStride: 12, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 13}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 12}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 4}, |
| {format: 'float16x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| await gc(); |
| let texture92 = device0.createTexture({ |
| label: '\u{1faf1}\u{1f942}\ucadb\uadda\u{1fc16}\u0eb0\u5b6d\u7ad6', |
| size: {width: 97, height: 60, depthOrArrayLayers: 88}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup27, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer63, 'uint32', 20, 33); |
| } catch {} |
| try { |
| buffer66.unmap(); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let imageData14 = new ImageData(8, 24); |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 176, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 557, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let texture93 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView123 = texture8.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let texture94 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView124 = texture24.createView({}); |
| let externalTexture24 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| device0.queue.writeBuffer(buffer64, 0, new Float32Array(10250).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.289)), 133, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout7 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder80 = device0.createCommandEncoder({label: '\u0e01\u0dd9\u{1fb7c}\u4650\u{1f8fb}\u5b8f\u0b58'}); |
| let textureView125 = texture71.createView({arrayLayerCount: 2}); |
| let externalTexture25 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer60, 'uint16', 38, 8); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u34f6'); |
| } catch {} |
| await gc(); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup9, new Uint32Array(1491), 324, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup23, new Uint32Array(7), 0, 0); |
| } catch {} |
| let videoFrame17 = new VideoFrame(videoFrame6, {timestamp: 0}); |
| let texture95 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture96 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView126 = texture46.createView({dimension: '2d-array', aspect: 'all'}); |
| let renderPassEncoder14 = commandEncoder73.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView122, |
| clearValue: { r: 605.6, g: -167.7, b: 200.4, a: -988.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 233805484, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup0, new Uint32Array(2273), 193, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup37, new Uint32Array(1206), 237, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer93, 'uint32', 16, 28); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup35, new Uint32Array(409), 256, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(7, buffer71, 0); |
| } catch {} |
| let texture97 = device0.createTexture({ |
| size: {width: 32, height: 48, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder15 = commandEncoder64.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView114, |
| clearValue: { r: -359.6, g: 756.6, b: 959.7, a: 213.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer38, 'uint32', 8, 18); |
| } catch {} |
| let buffer101 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST}); |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup0, new Uint32Array(1186), 17, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(1, buffer77); |
| } catch {} |
| try { |
| computePassEncoder2.insertDebugMarker('\ueebf'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 0, new Float32Array(1275).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.128)), 131, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(53); }; |
| } catch {} |
| let texture98 = device0.createTexture({ |
| size: [97, 60, 126], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView127 = texture71.createView({dimension: 'cube', baseArrayLayer: 1, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder10.copyBufferToBuffer(buffer81, 8, buffer64, 4, 24); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(54); }; |
| } catch {} |
| document.body.prepend(canvas0); |
| try { |
| buffer92.label = '\u08d3\u0537\uf10f'; |
| } catch {} |
| let buffer102 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDIRECT}); |
| let texture99 = device0.createTexture({ |
| size: [4, 6, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView128 = texture16.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup0, new Uint32Array(2864), 976, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 58, 15); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer82, 0, 2); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToTexture({ |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 700 */ |
| offset: 700, |
| bytesPerRow: 41472, |
| buffer: buffer11, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let sampler19 = device0.createSampler({addressModeW: 'repeat', mipmapFilter: 'nearest'}); |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup35, new Uint32Array(1635), 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer96, 0, 209); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let pipeline17 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2}}); |
| let autogeneratedBindGroupLayout8 = pipeline0.getBindGroupLayout(1); |
| let commandEncoder82 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder0.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline14); |
| } catch {} |
| let texture100 = device0.createTexture({ |
| size: [2, 2, 9], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup42, new Uint32Array(127), 55, 0); |
| } catch {} |
| try { |
| commandEncoder34.copyBufferToBuffer(buffer95, 12, buffer7, 4, 8); |
| } catch {} |
| let buffer103 = device0.createBuffer({ |
| size: 288, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer69, 'uint16', 34, 5); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer9, 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer9, 36, 5); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 150, y: 10, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 120, y: 24, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 90, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline18 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x4242e59}, |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.BLUE}]}, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex6', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 44, |
| attributes: [ |
| {format: 'sint32x2', offset: 12, shaderLocation: 15}, |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 9}, |
| {format: 'float16x4', offset: 0, shaderLocation: 13}, |
| {format: 'unorm8x4', offset: 16, shaderLocation: 4}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list'}, |
| }); |
| let commandEncoder83 = device0.createCommandEncoder(); |
| let texture101 = device0.createTexture({size: [780], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer38, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer82, 0, 9); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder84 = device0.createCommandEncoder(); |
| let texture102 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 19}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup1, new Uint32Array(702), 191, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer68, 0, 19); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| document.body.append(canvas3); |
| await gc(); |
| let textureView129 = texture99.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup35, new Uint32Array(2738), 737, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.drawIndexedIndirect(buffer102, 8); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture103 = device0.createTexture({ |
| size: [1560, 96, 1], |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle2 = renderBundleEncoder4.finish({}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline18); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup43 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 6, resource: {buffer: buffer81}}, {binding: 58, resource: {buffer: buffer21, size: 824}}], |
| }); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let texture104 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 233}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView130 = texture55.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer9, 'uint32', 28, 33); |
| } catch {} |
| try { |
| renderPassEncoder10.insertDebugMarker('\u01a5'); |
| } catch {} |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let texture105 = device0.createTexture({ |
| size: [97, 60, 1], |
| sampleCount: 4, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView131 = texture75.createView({mipLevelCount: 1, baseArrayLayer: 5, arrayLayerCount: 5}); |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup27, [0]); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer92.unmap(); |
| } catch {} |
| try { |
| commandEncoder79.resolveQuerySet(querySet0, 31, 10, buffer1, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| document.body.prepend(img0); |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'bt2020_12bit'} }); |
| let texture106 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let arrayBuffer6 = buffer67.getMappedRange(64, 0); |
| try { |
| device0.queue.writeBuffer(buffer101, 0, new Uint32Array(681).map((_, i) => i * 1), 91, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 1, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 116, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView132 = texture39.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0}); |
| let externalTexture26 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder78.copyBufferToBuffer(buffer103, 12, buffer66, 52, 20); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(65232)), 186, 4); |
| } catch {} |
| let pipeline19 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}}); |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 0, resource: externalTexture13}, |
| {binding: 1, resource: externalTexture3}, |
| {binding: 138, resource: textureView7}, |
| ], |
| }); |
| let textureView133 = texture63.createView({}); |
| let renderPassEncoder16 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView86, |
| clearValue: { r: 391.9, g: 986.8, b: 319.2, a: -445.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 240}, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup11, [0]); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer82, 4, new DataView(new Uint8Array(12375).map((_, i) => i).buffer), 7978, 20); |
| } catch {} |
| let autogeneratedBindGroupLayout9 = pipeline1.getBindGroupLayout(0); |
| let texture107 = device0.createTexture({ |
| size: [2, 2, 14], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup22, [0]); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup11, new Uint32Array(678), 44, 1); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup32, new Uint32Array(337), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer55, 'uint32', 6_084, 1_329); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 2, y: 8, z: 10}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 23, y: 34, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise14; |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 216, resource: textureView43}, |
| {binding: 362, resource: textureView57}, |
| {binding: 7, resource: textureView65}, |
| {binding: 1, resource: textureView14}, |
| {binding: 11, resource: externalTexture20}, |
| {binding: 95, resource: {buffer: buffer56}}, |
| {binding: 13, resource: {buffer: buffer37}}, |
| {binding: 15, resource: {buffer: buffer8, offset: 0}}, |
| {binding: 4, resource: sampler16}, |
| {binding: 183, resource: textureView124}, |
| {binding: 0, resource: {buffer: buffer21, size: 1512}}, |
| {binding: 9, resource: sampler3}, |
| {binding: 29, resource: externalTexture0}, |
| {binding: 243, resource: textureView37}, |
| ], |
| }); |
| let commandEncoder87 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder20.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder14.setStencilReference(102); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer1, 'uint32', 0, 65); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline16); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 241, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 290, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 348, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 556, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 711, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let textureView134 = texture69.createView({baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder2.setPipeline(pipeline16); |
| } catch {} |
| try { |
| computePassEncoder1.insertDebugMarker('\ub18f'); |
| } catch {} |
| try { |
| renderBundleEncoder23.insertDebugMarker('\u0d0d'); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout10 = pipeline10.getBindGroupLayout(1); |
| try { |
| device0.queue.writeBuffer(buffer38, 4, new Uint32Array(252).map((_, i) => i * 6), 9, 0); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(9); }; |
| } catch {} |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let texture108 = device0.createTexture({ |
| size: [195, 120, 44], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView135 = texture36.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let renderPassEncoder17 = commandEncoder26.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView93, |
| clearValue: { r: 473.6, g: 907.3, b: -235.7, a: 311.5, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup16, new Uint32Array(1475), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(1, buffer96, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup29, new Uint32Array(486), 143, 0); |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 60 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1250 */ |
| offset: 1250, |
| bytesPerRow: 40704, |
| buffer: buffer11, |
| }, { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 60, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| let textureView136 = texture71.createView({dimension: 'cube', baseMipLevel: 0}); |
| let texture109 = device0.createTexture({ |
| size: {width: 32, height: 48, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView137 = texture54.createView({}); |
| let renderPassEncoder18 = commandEncoder88.beginRenderPass({ |
| colorAttachments: [{view: textureView129, loadOp: 'load', storeOp: 'store'}], |
| timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 141}, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup6, [0]); |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup24, new Uint32Array(776), 173, 1); |
| } catch {} |
| let textureView138 = texture70.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup42, new Uint32Array(52), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(1, buffer68, 8); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| document.body.prepend(canvas0); |
| try { |
| externalTexture5.label = '\ucc35\u8f33\ue279\u1ab1\u0aa9\uec98\u0c26'; |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer93, 'uint32', 4, 20); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 419, y: 6, z: 14}, |
| aspect: 'all', |
| }, new Uint8Array(409_892).fill(142), /* required buffer size: 409_892 */ |
| {offset: 144, bytesPerRow: 2514, rowsPerImage: 47}, {width: 310, height: 22, depthOrArrayLayers: 4}); |
| } catch {} |
| let pipeline20 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule6, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 100, |
| attributes: [ |
| {format: 'sint8x4', offset: 24, shaderLocation: 12}, |
| {format: 'snorm16x2', offset: 36, shaderLocation: 7}, |
| {format: 'float32x4', offset: 0, shaderLocation: 10}, |
| {format: 'sint32x4', offset: 4, shaderLocation: 9}, |
| {format: 'uint8x4', offset: 20, shaderLocation: 1}, |
| {format: 'float32x2', offset: 8, shaderLocation: 13}, |
| {format: 'sint32x4', offset: 32, shaderLocation: 15}, |
| {format: 'uint32x2', offset: 20, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 24, shaderLocation: 5}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 4}, |
| {format: 'unorm16x2', offset: 72, shaderLocation: 2}, |
| {format: 'sint32x2', offset: 12, shaderLocation: 6}, |
| {format: 'float32x2', offset: 40, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 3}, |
| {format: 'sint32', offset: 0, shaderLocation: 8}, |
| {format: 'uint32x4', offset: 12, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0); }; |
| } catch {} |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| struct T3 { |
| @size(60) f0: u32, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| @group(0) @binding(138) var st9: texture_storage_2d<r32uint, read_write>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* used global variables: st9 */ |
| fn fn1() { |
| var vf70 = fn0(); |
| textureStore(st9, vec2i(vf70[unconst_u32(779409636)][unconst_u32(1664949393)]), vec4u(vec4u(unconst_u32(872535014), unconst_u32(886026875), unconst_u32(1554307756), unconst_u32(615857499)))); |
| vf70[unconst_u32(1916931944)][unconst_u32(181257650)] -= bitcast<i32>(cos(vec2h(unconst_f16(9399.2), unconst_f16(22657.0)))); |
| let vf71: u32 = atomicLoad(&vw9[0]); |
| atomicOr(&vw9[unconst_u32(227243673)], unconst_u32(162317398)); |
| vf70[unconst_u32(366354368)][atomicLoad(&(*&vw9)[u32((vec2i(unconst_i32(64302493), unconst_i32(164098056)) >> vec2u(unconst_u32(1484097364), unconst_u32(40129479))).x)])] = i32(atomicExchange(&(*&vw10), unconst_u32(694249108))); |
| let vf72: vec3f = sign(vec3f(unconst_f32(-0.00104e-43), unconst_f32(0.1436e24), unconst_f32(0.3609))); |
| { |
| var vf73: u32 = atomicExchange(&(*&vw9)[unconst_u32(27327894)], unconst_u32(467934538)); |
| var vf74 = fn0(); |
| let vf75: vec3f = acosh(vec3f(unconst_f32(0.08377), unconst_f32(0.02502), unconst_f32(-0.1215))); |
| vf73 = (vec2u(unconst_u32(642445795), unconst_u32(321765283)) ^ vec2u(unconst_u32(249643771), unconst_u32(483690803))).r; |
| let vf76: ptr<workgroup, atomic<u32>> = &vw10; |
| } |
| vf70[unconst_u32(168221586)][unconst_u32(246754612)] &= vec4i((f16(atomicLoad(&(*&vw10))) % vec4h(unconst_f16(7982.4), unconst_f16(17542.8), unconst_f16(-4059.4), unconst_f16(10872.2))))[2]; |
| atomicAnd(&vw9[unconst_u32(734985161)], unconst_u32(490350613)); |
| var vf77 = fn0(); |
| return; |
| _ = st9; |
| } |
| |
| @group(0) @binding(1) var et10: texture_external; |
| |
| struct ComputeInput8 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct VertexInput38 { |
| @location(5) @interpolate(perspective) location_5: vec2f, |
| } |
| |
| override override21: i32 = 160661106; |
| |
| struct VertexInput37 { |
| @location(12) @interpolate(flat) location_12: i32, |
| @location(8) location_8: vec2u, |
| @location(1) @interpolate(flat) location_1: u32, |
| @location(3) @interpolate(perspective) location_3: f16, |
| @location(11) location_11: vec2h, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(0) location_0: vec4u, |
| @location(9) location_9: vec2u, |
| @builtin(instance_index) instance_index: u32, |
| @location(7) location_7: vec4h, |
| @location(4) @interpolate(flat) location_4: i32, |
| @location(6) @interpolate(flat, first) location_6: vec2i, |
| @location(10) @interpolate(linear, center) location_10: vec4h, |
| @location(15) @interpolate(perspective, center) location_15: f16, |
| @location(13) @interpolate(flat) location_13: vec2u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct ComputeInput7 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn4(a0: vec4<bool>) -> vec2i { |
| var out: vec2i; |
| let vf84: u32 = pack4xU8(vec4u(unconst_u32(297277638), unconst_u32(259446323), unconst_u32(1399474806), unconst_u32(429180770))); |
| return out; |
| } |
| |
| struct T1 { |
| f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn3(a0: texture_storage_2d<r32uint, read_write>, a1: array<array<array<vec2f, 1>, 3>, 1>) -> vec2h { |
| var out: vec2h; |
| var vf83: array<vec2f, 1> = a1[unconst_u32(76708996)][unconst_u32(1017993218)]; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| fn fn0() -> array<array<i32, 1>, 3> { |
| var out: array<array<i32, 1>, 3>; |
| let vf68: vec4i = min(vec4i(out[2][0]), vec4i(unconst_i32(157750032), unconst_i32(449974239), unconst_i32(128397415), unconst_i32(-359041587))); |
| out[unconst_u32(127189776)][unconst_u32(1846819490)] &= bitcast<i32>(reflect(vec3f(unconst_f32(0.07386e-41), unconst_f32(0.2390), unconst_f32(0.2312e-30)), vec3f(unconst_f32(-0.1266e1), unconst_f32(-0.00696), unconst_f32(0.06259e-28)))[1]); |
| out[unconst_u32(646167299)][unconst_u32(277810765)] |= vec3i( !vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false))).y; |
| let ptr31: ptr<function, array<i32, 1>> = &out[unconst_u32(62256696)]; |
| let vf69: vec3f = reflect(vec3f(unconst_f32(0.06261), unconst_f32(0.1816), unconst_f32(0.2063)), vec3f(unconst_f32(-0.3308), unconst_f32(0.04972e19), unconst_f32(0.01011e-19))); |
| out[2][u32(dot(vec3f(unconst_f32(0.05070e-3), unconst_f32(0.02582), unconst_f32(0.01765)), vec3f(unconst_f32(0.00293), unconst_f32(0.03568e-32), unconst_f32(0.02202e-11))))] ^= i32(pack2x16unorm(vec2f( !vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)).gr))); |
| let ptr32: ptr<function, i32> = &(*ptr31)[0]; |
| out[unconst_u32(1025354197)][unconst_u32(805046045)] -= i32(countOneBits(pack2x16unorm(vec2f(unconst_f32(0.1602e5), unconst_f32(0.01523e-21))))); |
| return out; |
| } |
| |
| var<workgroup> vw9: array<atomic<u32>, 1>; |
| |
| /* used global variables: et10, st9 */ |
| fn fn6() { |
| let vf85: u32 = pack2x16float(vec2f(unconst_f32(0.01117), unconst_f32(0.2143e-44))); |
| switch u32(select(vec3h(unconst_f16(17446.0), unconst_f16(8387.6), unconst_f16(8088.3)), vec3h(unconst_f16(4549.5), unconst_f16(-16759.7), unconst_f16(4336.4)), unconst_bool(true)).z) { |
| case default { |
| var vf86: vec3f = atan2(vec3f(unconst_f32(0.1407e16), unconst_f32(0.1484), unconst_f32(0.4101e27)), fract(vec2f(unconst_f32(0.2387e-5), unconst_f32(0.06268e-29))).ggr); |
| vf86 = vf86; |
| let vf87: vec4u = textureLoad(st9, vec2i(bitcast<i32>(vf86[unconst_u32(657425670)]))); |
| _ = st9; |
| } |
| } |
| var vf88: vec3h = select(vec3h(unconst_f16(-19965.8), unconst_f16(736.1), unconst_f16(26113.1)), vec3h(textureDimensions(et10).xyx.bgg.ggr), unconst_bool(false)); |
| var vf89 = fn3(st9, array<array<array<vec2f, 1>, 3>, 1>(array<array<vec2f, 1>, 3>(array<vec2f, 1>(unpack2x16snorm(vf85)), array<vec2f, 1>(unpack2x16float(vf85)), array<vec2f, 1>(vec2f(f32(vf85)))))); |
| vf88 = vec3h(faceForward(vec2f(unconst_f32(0.2822), unconst_f32(0.07022)), vec2f(unconst_f32(0.1990e-6), unconst_f32(0.1095e-37)), vec2f(unconst_f32(0.00102), unconst_f32(0.1307e-33))).yxy.rbb); |
| vf88 = vec3h(asinh(vec2f(unconst_f32(-0.01883), unconst_f32(0.05587))).rrr); |
| _ = st9; |
| _ = et10; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw10: atomic<u32>; |
| |
| struct T2 { |
| @align(32) f0: array<u32>, |
| } |
| |
| /* used global variables: st9 */ |
| fn fn2(a0: ptr<workgroup, array<atomic<u32>, 1>>, a1: ptr<workgroup, atomic<u32>>) -> vec2u { |
| var out: vec2u; |
| loop { |
| out += vec2u(u32(sin(unconst_f16(481.4)))); |
| textureStore(st9, vec2i(unconst_i32(13151919), unconst_i32(24340647)), vec4u(vec4u(unconst_u32(180428355), unconst_u32(838949435), unconst_u32(325986034), unconst_u32(292179773)))); |
| break; |
| _ = st9; |
| } |
| atomicOr(&(*a0)[unconst_u32(497160241)], unconst_u32(1388439777)); |
| for (var it4=vec3u(cross(vec3h(unconst_f16(8154.1), unconst_f16(17024.6), unconst_f16(6455.0)), vec3h(unconst_f16(308.5), unconst_f16(2423.5), unconst_f16(10116.8))))[2]; it4<(pack2x16float(vec2f(unconst_f32(0.05409), unconst_f32(0.02753e18))) & 0xfff); it4++) { |
| switch pack2x16unorm(vec2f(unconst_f32(0.1200), unconst_f32(0.1004))) { |
| default { |
| let vf78: ptr<workgroup, atomic<u32>> = a1; |
| let vf79: vec3f = degrees(vec3f(bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.3256), unconst_f32(0.1094), unconst_f32(0.09131), unconst_f32(0.1055e4)))))); |
| let ptr33: ptr<workgroup, array<atomic<u32>, 1>> = &(*a0); |
| atomicCompareExchangeWeak(&(*a1), unconst_u32(509407216), unconst_u32(491414470)); |
| break; |
| } |
| case 217364521, 2952394716, 189877490 { |
| out *= vec2u(pack4x8unorm(vec4f(unconst_f32(0.05710e13), unconst_f32(0.3001), unconst_f32(0.1653), unconst_f32(0.4703e17)))); |
| out ^= vec2u(atomicLoad(&(*a1))); |
| var vf80: u32 = pack4xU8Clamp(vec4u(unconst_u32(52897898), unconst_u32(1186932139), unconst_u32(18681141), unconst_u32(9631125))); |
| } |
| } |
| let vf81: ptr<workgroup, array<atomic<u32>, 1>> = a0; |
| } |
| let vf82: i32 = override21; |
| loop { |
| atomicCompareExchangeWeak(&(*a0)[unconst_u32(458800326)], unconst_u32(1468678890), unconst_u32(18553879)); |
| break; |
| } |
| atomicAdd(&(*a1), unconst_u32(408811501)); |
| return out; |
| _ = override21; |
| _ = st9; |
| } |
| |
| /* used global variables: st9 */ |
| fn fn5() -> vec4u { |
| var out: vec4u; |
| let ptr34: ptr<workgroup, atomic<u32>> = &(*&vw9)[unconst_u32(156111521)]; |
| fn1(); |
| atomicExchange(&vw10, unconst_u32(989230253)); |
| atomicCompareExchangeWeak(&vw9[unconst_u32(2452003168)], unconst_u32(148337736), unconst_u32(1079488619)); |
| return out; |
| _ = st9; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex8(a0: VertexInput37, a1: VertexInput38, @location(2) location_2: vec2f) -> @builtin(position) vec4f { |
| var out: vec4f; |
| let vf90: vec4h = a0.location_7; |
| out *= vec4f(f32(a0.location_3)); |
| var vf91: u32 = a0.location_8[unconst_u32(309184240)]; |
| let vf92: i32 = a0.location_12; |
| _ = fn0(); |
| fn0(); |
| out += vec4f(f32(a0.location_10[unconst_u32(241447029)])); |
| out *= bitcast<vec4f>(a0.location_6.xyxy); |
| switch bitcast<vec2i>((vec2u(unconst_u32(247271241), unconst_u32(1524110376)) ^ vec2u(unconst_u32(132236716), unconst_u32(721936191))).gr)[0] { |
| default: { |
| out = vec4f(step(vec2h(unconst_f16(19595.0), unconst_f16(19496.5)), vec2h(unconst_f16(22481.0), unconst_f16(14633.5))).rrgr.rbra.agbb); |
| var vf93: vec4u = a0.location_0; |
| var vf94 = fn0(); |
| break; |
| } |
| case 432987473: { |
| out *= vec4f(a0.location_11.yyyx); |
| } |
| } |
| var vf95: vec2u = (vec2u(unconst_u32(1271652623), unconst_u32(225418961)) ^ vec2u(unconst_u32(321889485), unconst_u32(647444184))); |
| return out; |
| } |
| |
| /* used global variables: st9 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute7(a0: ComputeInput7, a1: ComputeInput8, @builtin(workgroup_id) workgroup_id: vec3u) { |
| textureStore(st9, vec2i(unconst_i32(145245795), unconst_i32(333028705)), vec4u(vec4u(unconst_u32(193183847), unconst_u32(273534955), unconst_u32(194059343), unconst_u32(165524152)))); |
| var vf96 = fn2(&vw9, &(*&vw9)[unconst_u32(40403026)]); |
| let ptr35: ptr<workgroup, atomic<u32>> = &vw9[0]; |
| atomicExchange(&vw10, unconst_u32(558559400)); |
| let ptr36: ptr<workgroup, atomic<u32>> = &(*&vw9)[0]; |
| switch a0.local_invocation_id[1] { |
| case default { |
| var vf97 = fn4(vec4<bool>(bool(atomicLoad(&(*&vw9)[0])))); |
| fn1(); |
| textureStore(st9, vec2i(unconst_i32(88173932), unconst_i32(273320602)), vec4u(vec4u(unconst_u32(750490941), unconst_u32(2619603389), unconst_u32(825616856), unconst_u32(793929356)))); |
| var vf98 = fn2(&vw9, &vw10); |
| vf97 ^= vec2i(bitcast<i32>(atomicLoad(&vw9[unconst_u32(441216497)]))); |
| var vf99: u32 = pack4xI8Clamp(vec4i(unconst_i32(389834036), unconst_i32(255797744), unconst_i32(150357581), unconst_i32(273449114))); |
| _ = override21; |
| _ = st9; |
| } |
| } |
| textureStore(st9, vec2i(unconst_i32(910674850), unconst_i32(136520691)), vec4u(vec4u(unconst_u32(107514336), unconst_u32(17636719), unconst_u32(1647632312), unconst_u32(119299317)))); |
| _ = override21; |
| _ = st9; |
| }`, |
| }); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 3, resource: textureView3}, |
| {binding: 43, resource: {buffer: buffer80}}, |
| {binding: 6, resource: {buffer: buffer34}}, |
| {binding: 58, resource: {buffer: buffer21, offset: 256, size: 1140}}, |
| ], |
| }); |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup17, new Uint32Array(954), 518, 1); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline2); |
| } catch {} |
| let texture110 = device0.createTexture({ |
| size: {width: 195, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 376, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(978).fill(85), /* required buffer size: 978 */ |
| {offset: 978}, {width: 44, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: { |
| fullRange: true, |
| matrix: 'bt709', |
| primaries: 'jedecP22Phosphors', |
| transfer: 'bt1361ExtendedColourGamut', |
| } }); |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 33, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 40, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 45, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 84, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 117, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 148, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 201, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 210, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 211, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 219, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 255, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 264, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 269, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 284, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 386, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder92 = device0.createCommandEncoder(); |
| let texture111 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1181}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView139 = texture66.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer55, 'uint16', 1_198, 569); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(3, buffer8, 4); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer69, 'uint32', 0, 7); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.append(canvas3); |
| let bindGroup47 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup19, new Uint32Array(479), 22, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer63, 'uint16', 18, 40); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline20); |
| } catch {} |
| try { |
| commandEncoder43.resolveQuerySet(querySet0, 41, 8, buffer60, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 1_136, new Uint32Array(3659).map((_, i) => i * 2), 1219, 100); |
| } catch {} |
| await gc(); |
| let imageData15 = new ImageData(104, 88); |
| let bindGroup48 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 13, resource: {buffer: buffer66}}, |
| {binding: 183, resource: textureView40}, |
| {binding: 95, resource: {buffer: buffer37}}, |
| {binding: 216, resource: textureView43}, |
| {binding: 243, resource: textureView112}, |
| {binding: 7, resource: textureView34}, |
| {binding: 362, resource: textureView28}, |
| {binding: 4, resource: sampler16}, |
| {binding: 9, resource: sampler3}, |
| {binding: 29, resource: externalTexture25}, |
| {binding: 11, resource: externalTexture16}, |
| {binding: 1, resource: textureView22}, |
| {binding: 15, resource: {buffer: buffer56}}, |
| {binding: 0, resource: {buffer: buffer21, size: 1724}}, |
| ], |
| }); |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer60, 'uint32', 64, 2); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(7, buffer77, 36); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let autogeneratedBindGroupLayout11 = pipeline0.getBindGroupLayout(0); |
| let buffer104 = device0.createBuffer({size: 1288, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 958}); |
| let texture112 = gpuCanvasContext2.getCurrentTexture(); |
| let computePassEncoder22 = commandEncoder69.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 120, endOfPassWriteIndex: 107}}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup22, [0]); |
| } catch {} |
| try { |
| commandEncoder83.copyBufferToTexture({ |
| /* bytesInLastRow: 832 widthInBlocks: 416 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1114 */ |
| offset: 1114, |
| bytesPerRow: 11776, |
| buffer: buffer11, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 6, y: 77, z: 0}, |
| aspect: 'all', |
| }, {width: 416, height: 114, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup33); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer90, 'uint16', 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer59, 24, 10); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer60, 'uint32', 12, 40); |
| } catch {} |
| try { |
| renderPassEncoder16.insertDebugMarker('\ub204'); |
| } catch {} |
| let buffer105 = device0.createBuffer({size: 175, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder22.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer9, 'uint16', 18, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer89, 60, 52); |
| } catch {} |
| try { |
| commandEncoder85.resolveQuerySet(querySet0, 48, 26, buffer70, 0); |
| } catch {} |
| await gc(); |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpteSt4281', transfer: 'iec6196624'} }); |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let bindGroup49 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 10, resource: {buffer: buffer105, size: 60}}], |
| }); |
| let textureView140 = texture102.createView({dimension: '3d', mipLevelCount: 1}); |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 8, new Float32Array(1367).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6954)), 608, 0); |
| } catch {} |
| let imageData16 = new ImageData(16, 12); |
| let videoFrame21 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| let buffer106 = device0.createBuffer({ |
| size: 220, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let sampler20 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 90.36, |
| }); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer90, 'uint16', 40, 114); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup13, new Uint32Array(153), 6, 0); |
| } catch {} |
| try { |
| commandEncoder53.insertDebugMarker('\u0ecc'); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let texture113 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 42}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup11, [0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer19, 'uint32', 0, 8); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer53, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(5, buffer62); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| await gc(); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let commandBuffer0 = commandEncoder78.finish(); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup17, [0]); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline13); |
| } catch {} |
| try { |
| buffer75.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 0, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 100, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let buffer107 = device0.createBuffer({ |
| size: 2968, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let texture114 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView141 = texture80.createView({}); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup17, new Uint32Array(3), 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 204, new DataView(new ArrayBuffer(60952)), 1329, 0); |
| } catch {} |
| let imageData17 = new ImageData(152, 8); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(38); }; |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup24, new Uint32Array(3547), 1_140, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer68, 0, 0); |
| } catch {} |
| try { |
| commandEncoder56.copyBufferToBuffer(buffer50, 0, buffer2, 0, 0); |
| } catch {} |
| let bindGroup50 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 6, resource: {buffer: buffer80}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 43, resource: {buffer: buffer37}}, |
| ], |
| }); |
| let textureView142 = texture51.createView({dimension: '2d', baseArrayLayer: 4}); |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup46, new Uint32Array(837), 106, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer60, 'uint32', 4, 12); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer82, 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline8); |
| } catch {} |
| let texture115 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 337}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup14, new Uint32Array(60), 14, 1); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer71, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup37); |
| } catch {} |
| document.body.append(canvas2); |
| let bindGroup51 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer103}}, |
| {binding: 176, resource: {buffer: buffer21, size: 1928}}, |
| {binding: 557, resource: externalTexture11}, |
| ], |
| }); |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup33, new Uint32Array(7015), 1_415, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup25, new Uint32Array(433), 96, 1); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let textureView143 = texture82.createView({aspect: 'all', baseMipLevel: 0}); |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 4_296, new Uint32Array(13042).map((_, i) => i * 10), 1722, 680); |
| } catch {} |
| let pipeline21 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}}); |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let texture116 = device0.createTexture({ |
| size: [32, 48, 8], |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder18.setVertexBuffer(7, buffer43); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup35, new Uint32Array(3075), 966, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup15, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(4, buffer71, 0, 1); |
| } catch {} |
| try { |
| buffer65.unmap(); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer5}}], |
| }); |
| let texture117 = device0.createTexture({size: [8, 12, 2], dimension: '3d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup9); |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer52, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer8, 0, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 0, new Uint32Array(2933).map((_, i) => i * 1), 1310, 0); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'bt709', transfer: 'gamma28curve'} }); |
| let buffer108 = device0.createBuffer({ |
| size: 24, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let texture118 = device0.createTexture({size: {width: 780}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup16, new Uint32Array(393), 10, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(7, buffer107, 0, 1_556); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let imageData18 = new ImageData(68, 4); |
| let bindGroup53 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer64}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 6, resource: {buffer: buffer32}}, |
| ], |
| }); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder5.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(3, buffer43, 4, 2); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer65, 'uint16', 4, 16); |
| } catch {} |
| try { |
| commandEncoder37.copyTextureToTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 49}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture119 = device0.createTexture({ |
| size: [8, 12, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView144 = texture118.createView({label: '\u477d\u9a6b\u{1fe3c}\uba7b'}); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup22, new Uint32Array(4270), 2_290, 1); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline20); |
| } catch {} |
| let arrayBuffer7 = buffer67.getMappedRange(72, 0); |
| let buffer109 = device0.createBuffer({size: 60, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder105 = device0.createCommandEncoder(); |
| let texture120 = device0.createTexture({size: [2, 2, 40], mipLevelCount: 2, dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup40, new Uint32Array(2669), 154, 0); |
| } catch {} |
| try { |
| commandEncoder67.resolveQuerySet(querySet0, 107, 2, buffer6, 0); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 10, resource: {buffer: buffer107, offset: 1280}}], |
| }); |
| let texture121 = device0.createTexture({ |
| size: {width: 32, height: 48, depthOrArrayLayers: 8}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder19 = commandEncoder68.beginRenderPass({ |
| colorAttachments: [{view: textureView129, loadOp: 'load', storeOp: 'store'}], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer108, 'uint32', 4, 6); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(21280)), 396, 0); |
| } catch {} |
| await gc(); |
| let buffer110 = device0.createBuffer({ |
| size: 244, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let textureView145 = texture121.createView({}); |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer59); |
| } catch {} |
| await gc(); |
| try { |
| commandEncoder106.insertDebugMarker('\u07db'); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 15, resource: {buffer: buffer5}}, |
| {binding: 125, resource: textureView38}, |
| {binding: 166, resource: textureView88}, |
| {binding: 4, resource: {buffer: buffer107}}, |
| {binding: 251, resource: {buffer: buffer105, size: 28}}, |
| {binding: 81, resource: externalTexture4}, |
| {binding: 148, resource: {buffer: buffer8}}, |
| {binding: 0, resource: {buffer: buffer37}}, |
| {binding: 12, resource: textureView44}, |
| {binding: 220, resource: {buffer: buffer94}}, |
| {binding: 141, resource: {buffer: buffer21, size: 212}}, |
| {binding: 2, resource: textureView97}, |
| {binding: 152, resource: textureView87}, |
| {binding: 1, resource: externalTexture4}, |
| {binding: 11, resource: textureView26}, |
| {binding: 86, resource: {buffer: buffer21, size: 2048}}, |
| {binding: 106, resource: {buffer: buffer21, size: 1256}}, |
| {binding: 5, resource: {buffer: buffer80, offset: 0}}, |
| {binding: 6, resource: textureView0}, |
| {binding: 3, resource: textureView80}, |
| ], |
| }); |
| let textureView146 = texture121.createView({}); |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer9); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline16); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, offset: 0, size: 2360}}, |
| {binding: 6, resource: {buffer: buffer105, size: 60}}, |
| ], |
| }); |
| let buffer111 = device0.createBuffer({ |
| size: 431, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup18, new Uint32Array(422), 156, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(5, buffer62); |
| } catch {} |
| try { |
| renderPassEncoder12.insertDebugMarker('\u{1f88f}'); |
| } catch {} |
| let pipeline22 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]}, |
| vertex: { |
| module: shaderModule7, |
| constants: {override18: 1}, |
| buffers: [ |
| { |
| arrayStride: 324, |
| attributes: [ |
| {format: 'float32x4', offset: 4, shaderLocation: 8}, |
| {format: 'float16x4', offset: 164, shaderLocation: 13}, |
| {format: 'sint32x4', offset: 152, shaderLocation: 6}, |
| {format: 'uint8x4', offset: 108, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 16, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 126, shaderLocation: 4}, |
| {format: 'snorm16x4', offset: 92, shaderLocation: 0}, |
| {format: 'uint32', offset: 104, shaderLocation: 11}, |
| {format: 'unorm16x4', offset: 40, shaderLocation: 14}, |
| {format: 'sint16x2', offset: 116, shaderLocation: 15}, |
| {format: 'uint8x2', offset: 10, shaderLocation: 9}, |
| {format: 'uint32', offset: 32, shaderLocation: 7}, |
| {format: 'float16x4', offset: 48, shaderLocation: 5}, |
| {format: 'float32x2', offset: 8, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let texture122 = device0.createTexture({ |
| size: [32, 48, 8], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup33, new Uint32Array(2051), 291, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer74, 'uint16', 4, 14); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer68, 4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 0, new DataView(new Uint8Array(2423).map((_, i) => i).buffer), 954, 4); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| let texture123 = device0.createTexture({ |
| size: [780], |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder19.beginOcclusionQuery(224); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer59); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer19, 'uint32', 8, 4); |
| } catch {} |
| try { |
| commandEncoder27.insertDebugMarker('\u40e6'); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(14); }; |
| } catch {} |
| await gc(); |
| let bindGroup57 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer22}}]}); |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup50, [0]); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup15, new Uint32Array(67), 5, 1); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndirect(buffer104, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer107, size: 592}}, |
| {binding: 6, resource: {buffer: buffer94}}, |
| {binding: 43, resource: {buffer: buffer51}}, |
| {binding: 3, resource: textureView17}, |
| ], |
| }); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup47, new Uint32Array(1136), 443, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 16, new Float32Array(13802).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.058)), 208, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(86).fill(116), /* required buffer size: 86 */ |
| {offset: 86, rowsPerImage: 73}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline23 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule4, entryPoint: 'fragment3', targets: [{format: 'rg8sint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 8, |
| attributes: [ |
| {format: 'sint32', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 2, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| { |
| arrayStride: 24, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 0}, |
| {format: 'unorm16x2', offset: 8, shaderLocation: 9}, |
| {format: 'unorm8x2', offset: 10, shaderLocation: 2}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x2', offset: 8, shaderLocation: 8}, |
| {format: 'float32x3', offset: 0, shaderLocation: 6}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 14}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint32', offset: 8, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 4}, |
| {format: 'uint8x4', offset: 4, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', cullMode: 'front'}, |
| }); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer112 = device0.createBuffer({size: 200, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, mappedAtCreation: false}); |
| let texture124 = device0.createTexture({ |
| size: {width: 780}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer90, 'uint16', 92, 92); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let canvas4 = document.createElement('canvas'); |
| let bindGroup59 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 1, resource: externalTexture9}, {binding: 3, resource: textureView17}], |
| }); |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let texture125 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup2, new Uint32Array(778), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer96); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder53.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 660, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture81, |
| mipLevel: 0, |
| origin: {x: 55, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 146, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| try { |
| renderPassEncoder10.drawIndirect(buffer68, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 0, new Uint32Array(2119).map((_, i) => i * 1), 61, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup29, []); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer19, 'uint16', 2, 24); |
| } catch {} |
| try { |
| canvas4.getContext('webgl'); |
| } catch {} |
| let shaderModule9 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| @group(0) @binding(3) var tex8: texture_depth_2d; |
| |
| var<private> vp5: vec2h = vec2h(18067.8, 31755.2); |
| |
| struct FragmentInput11 { |
| @location(1) location_1: i32, |
| @location(5) @interpolate(flat) location_5: vec4u, |
| @location(9) @interpolate(perspective, sample) location_9: vec2h, |
| @location(3) @interpolate(flat, sample) location_3: vec2i, |
| @location(10) location_10: vec2u, |
| @location(4) location_4: f16, |
| @location(8) location_8: i32, |
| @location(7) @interpolate(linear) location_7: f16, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(58) var<storage, read_write> buffer115: array<array<VertexOutput7, 6>>; |
| |
| struct FragmentInput13 { |
| @builtin(position) position: vec4f, |
| } |
| |
| struct T1 { |
| f0: array<atomic<i32>>, |
| } |
| |
| struct FragmentInput10 { |
| @location(11) location_11: vec4h, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(6) var<storage, read_write> buffer113: FragmentInput13; |
| |
| struct FragmentInput12 { |
| @location(12) @interpolate(flat, centroid) location_12: vec2u, |
| @location(14) location_14: i32, |
| } |
| |
| struct ComputeInput10 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexOutput7 { |
| @location(11) @interpolate(linear, either) location_11: vec4h, |
| @location(12) location_12: vec2h, |
| @location(2) @interpolate(linear, either) location_2: vec2f, |
| @location(14) @interpolate(linear, first) location_14: vec2f, |
| @location(6) @interpolate(flat, sample) location_6: vec4u, |
| @location(4) @interpolate(flat, sample) location_4: vec4u, |
| @location(9) @interpolate(perspective, center) location_9: vec2h, |
| @location(13) location_13: f16, |
| @builtin(position) position: vec4f, |
| } |
| |
| struct FragmentInput16 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentInput15 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| var<private> vp6: array<vec4u, 1> = array<vec4u, 1>(); |
| |
| struct ComputeInput9 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| struct FragmentInput14 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| struct T0 { |
| @align(8) @size(8) f0: f32, |
| @size(96) f1: array<vec4i, 1>, |
| } |
| |
| struct FragmentOutput4 { |
| @location(0) @interpolate(flat) location_0: vec4i, |
| @builtin(sample_mask) sample_mask: u32, |
| @location(4) location_4: vec4i, |
| @location(6) @interpolate(flat) location_6: i32, |
| } |
| |
| /* used global variables: tex8 */ |
| @vertex |
| fn vertex9(@location(3) @interpolate(flat) location_3: vec4u) -> VertexOutput7 { |
| var out: VertexOutput7; |
| let vf100: i32 = (unconst_i32(58496300) >> unconst_u32(702921413)); |
| out.location_6 -= unpack4xU8(textureNumLevels(tex8)); |
| switch (vec3u(unconst_u32(294774848), unconst_u32(676599032), unconst_u32(20391420)) ^ vec3u(unconst_u32(136614264), unconst_u32(491687833), unconst_u32(261877405)))[0] { |
| case default, 90837187 { |
| let vf101: f16 = asinh(unconst_f16(153.1)); |
| { |
| out.position -= out.location_2.grrr; |
| out.position *= vec4f(out.position[unconst_u32(2660475302)]); |
| } |
| out.location_4 = vec4u(u32(out.location_13)); |
| } |
| } |
| let ptr37: ptr<function, vec2f> = &out.location_2; |
| var vf102: vec3u = (vec3u(unconst_u32(548258288), unconst_u32(281913024), unconst_u32(94541432)) ^ vec3u(unconst_u32(421353527), unconst_u32(1661938726), unconst_u32(465314353))); |
| return out; |
| _ = tex8; |
| } |
| |
| /* used global variables: buffer113 */ |
| @fragment |
| fn fragment7(a0: FragmentInput10, a1: FragmentInput11, @location(13) @interpolate(flat) location_13: i32, a3: FragmentInput12, a4: FragmentInput13, a5: FragmentInput14, a6: FragmentInput15, a7: FragmentInput16) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| if bool(vp6[unconst_u32(1230909475)].w) { |
| let vf103: vec3i = insertBits(vec3i(cross(vec3h(unconst_f16(4222.2), unconst_f16(199.3), unconst_f16(11740.4)), vec3h(unconst_f16(22941.1), unconst_f16(3022.2), unconst_f16(5542.5))).yyy), vec3i(unconst_i32(99694534), unconst_i32(396629056), unconst_i32(348528273)), unconst_u32(402945542), unconst_u32(3071262448)); |
| for (var jj86=0u; jj86<3; jj86++) { vp6[jj86] = vec4u(a0.location_11); } |
| let ptr38: ptr<private, array<vec4u, 1>> = &vp6; |
| let ptr39: ptr<function, u32> = &out.sample_mask; |
| let vf104: u32 = a6.sample_index; |
| let vf105: i32 = out.location_4[u32(a3.location_14)]; |
| } |
| buffer113.position = vec4f(a0.location_11); |
| var vf106: vec2u = a3.location_12; |
| if bool(a1.location_3[1]) { |
| out = FragmentOutput4(vec4i(i32(all(vec2<bool>(unconst_bool(true), unconst_bool(false))))), u32(all(vec2<bool>(unconst_bool(true), unconst_bool(false)))), vec4i(i32(all(vec2<bool>(unconst_bool(true), unconst_bool(false))))), i32(all(vec2<bool>(unconst_bool(true), unconst_bool(false))))); |
| out.location_0 ^= vec4i((mat4x2f() * mat3x4f())[unconst_i32(1)].grrr); |
| return out; |
| } |
| let ptr40: ptr<function, vec4i> = &out.location_4; |
| let ptr41: ptr<function, vec2u> = &vf106; |
| return out; |
| _ = buffer113; |
| } |
| |
| /* used global variables: buffer113, buffer115 */ |
| @compute @workgroup_size(3, 1, 1) |
| fn compute8(a0: ComputeInput9, @builtin(workgroup_id) workgroup_id: vec3u, a2: ComputeInput10, @builtin(num_workgroups) num_workgroups: vec3u) { |
| workgroupBarrier(); |
| let vf107: f32 = buffer113.position[unconst_u32(243744572)]; |
| switch i32(step(vec3h(unconst_f16(16185.2), unconst_f16(1822.2), unconst_f16(6434.4)), vec3h(unconst_f16(12018.9), unconst_f16(6845.1), unconst_f16(11524.1)))[0]) { |
| case 121796185: { |
| let vf108: ptr<storage, array<array<VertexOutput7, 6>>, read_write> = &buffer115; |
| let ptr42: ptr<storage, vec4u, read_write> = &(*vf108)[unconst_u32(512859561)][unconst_u32(1089890518)].location_6; |
| let vf109: u32 = buffer115[unconst_u32(250567114)][5].location_4[unconst_u32(1243180229)]; |
| _ = buffer115; |
| } |
| default { |
| buffer113.position = vec4f(f32((*&buffer115)[arrayLength(&(*&buffer115))][5].location_9[unconst_u32(202723226)])); |
| _ = buffer115; |
| _ = buffer113; |
| } |
| } |
| var vf110: f16 = (*&buffer115)[unconst_u32(297488736)][unconst_u32(1246402030)].location_9[unconst_u32(786742672)]; |
| vp5 -= vec2h(vp5[unconst_u32(268963631)]); |
| let ptr43: ptr<storage, vec4h, read_write> = &(*&buffer115)[unconst_u32(1433591947)][5].location_11; |
| _ = buffer115; |
| _ = buffer113; |
| }`, |
| }); |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder10.drawIndirect(buffer54, 8); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer111); |
| } catch {} |
| try { |
| commandEncoder104.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1982 */ |
| offset: 1982, |
| buffer: buffer11, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline24 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}}); |
| let bindGroup60 = device0.createBindGroup({layout: autogeneratedBindGroupLayout8, entries: [{binding: 10, resource: {buffer: buffer5}}]}); |
| let buffer116 = device0.createBuffer({size: 1372, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 47.37, |
| compare: 'never', |
| }); |
| try { |
| renderPassEncoder10.draw(462, 0, 356_351_064, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 0, new DataView(new Uint8Array(749).map((_, i) => i).buffer), 36, 4); |
| } catch {} |
| let pipeline25 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0}}); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup9, new Uint32Array(1227), 128, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(4, buffer82); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let pipeline26 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, targets: [{format: 'r16sint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule9, |
| buffers: [{arrayStride: 28, attributes: [{format: 'uint32x4', offset: 0, shaderLocation: 3}]}], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let bindGroup61 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer60}}], |
| }); |
| try { |
| renderBundleEncoder1.setVertexBuffer(6, buffer111, 0); |
| } catch {} |
| try { |
| buffer82.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder19.insertDebugMarker('\u{1fc33}'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer96); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame18, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 37, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer1 = commandEncoder41.finish(); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup11, [0]); |
| } catch {} |
| try { |
| computePassEncoder22.setBindGroup(3, bindGroup24, new Uint32Array(2054), 964, 1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup47, new Uint32Array(699), 111, 0); |
| } catch {} |
| try { |
| commandEncoder98.copyTextureToTexture({ |
| texture: texture89, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 41, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| await gc(); |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpte240m', transfer: 'bt2020_12bit'} }); |
| try { |
| renderBundleEncoder2.setPipeline(pipeline14); |
| } catch {} |
| try { |
| buffer103.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder11.pushDebugGroup('\u028e'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 104, new DataView(new ArrayBuffer(41836)), 2341, 0); |
| } catch {} |
| let texture126 = device0.createTexture({ |
| size: [32, 48, 8], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView147 = texture108.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup61, []); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer74, 'uint16', 6, 5); |
| } catch {} |
| try { |
| buffer34.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 5, y: 4, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(201_847).fill(192), /* required buffer size: 201_847 */ |
| {offset: 15, bytesPerRow: 649, rowsPerImage: 51}, {width: 321, height: 5, depthOrArrayLayers: 7}); |
| } catch {} |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rg8sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer69, 'uint32', 108, 0); |
| } catch {} |
| let buffer117 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let computePassEncoder23 = commandEncoder66.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 381, endOfPassWriteIndex: 281}}); |
| try { |
| computePassEncoder23.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer93, 'uint16', 2, 16); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer43, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(7, buffer35, 0, 6); |
| } catch {} |
| try { |
| commandEncoder102.resolveQuerySet(querySet0, 54, 9, buffer6, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame14, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 203, y: 16, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer118 = device0.createBuffer({ |
| size: 4580, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder18.setVertexBuffer(7, buffer9); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let buffer119 = device0.createBuffer({size: 32, usage: GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup51, new Uint32Array(48), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup17, [0]); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup35, new Uint32Array(3135), 207, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(1, buffer96); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder11.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let imageData19 = new ImageData(8, 40); |
| let buffer120 = device0.createBuffer({ |
| size: 200, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup39); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup8, new Uint32Array(280), 87, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder102.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 734 */ |
| offset: 734, |
| buffer: buffer11, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 5_556, new Uint32Array(4101).map((_, i) => i * 9), 855, 228); |
| } catch {} |
| let bindGroup62 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let texture127 = device0.createTexture({ |
| size: [97, 60, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView148 = texture118.createView({}); |
| let shaderModule10 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| /* used global variables: sam5, st12, tex10 */ |
| fn fn1() -> vec2u { |
| var out: vec2u; |
| for (var it5=vec3u(cross(vec3h(unconst_f16(15837.1), unconst_f16(922.6), unconst_f16(-2538.4)), vec3h(textureDimensions(st12).bgr)).brg).y; it5<(u32(textureGather(145195562 % 4, tex10, sam5, vec2f(unconst_f32(0.03195), unconst_f32(0.1793))).w) & 0xfff); it5++) { |
| vp8.whole = vec4h(textureLoad(st12, vec3i(unconst_i32(98739735), unconst_i32(551190652), unconst_i32(627311948))).yxzw.graa.brbr); |
| _ = st12; |
| } |
| vp7.fract = vp8.fract; |
| let vf111: vec2<bool> = (vec2f(unconst_f32(0.1909e7), unconst_f32(0.2574)) != unpack2x16snorm(pack4xI8(vec4i(unconst_i32(-327261159), unconst_i32(230531696), unconst_i32(425966946), unconst_i32(89512941))))); |
| out *= bitcast<vec2u>(vp8.whole); |
| return out; |
| _ = st12; |
| _ = tex10; |
| _ = sam5; |
| } |
| |
| @group(1) @binding(176) var<storage, read_write> buffer122: array<array<array<FragmentInput17, 2>, 50>>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct VertexOutput8 { |
| @builtin(position) position: vec4f, |
| } |
| |
| override override22 = 0.1719e14; |
| |
| struct VertexInput45 { |
| @location(11) @interpolate(perspective) location_11: f32, |
| @location(12) location_12: vec4h, |
| @location(1) @interpolate(flat, centroid) location_1: vec4i, |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| @group(1) @binding(557) var et13: texture_external; |
| |
| @group(2) @binding(556) var st12: texture_storage_3d<r32sint, read>; |
| |
| /* zero global variables used */ |
| fn fn2(a0: vec2u) -> vec2f { |
| var out: vec2f; |
| let ptr49: ptr<private, vec4h> = &vp8.whole; |
| let ptr50 = &vp8; |
| vp7.whole = vp8.fract; |
| let ptr51: ptr<private, vec4h> = &vp7.whole; |
| return out; |
| } |
| |
| struct FragmentInput19 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw11: vec4i; |
| |
| struct VertexInput43 { |
| @location(2) @interpolate(flat, first) location_2: vec2i, |
| } |
| |
| struct VertexInput41 { |
| @location(15) location_15: vec2h, |
| @location(12) @interpolate(flat) location_12: vec4i, |
| @location(1) location_1: vec2f, |
| @location(11) location_11: f16, |
| @location(7) @interpolate(flat, sample) location_7: vec2i, |
| @location(8) @interpolate(perspective, centroid) location_8: vec2f, |
| } |
| |
| @group(0) @binding(1) var et12: texture_external; |
| |
| /* used global variables: buffer122 */ |
| fn fn3(a0: f32) -> vec4f { |
| var out: vec4f; |
| let ptr52: ptr<workgroup, vec4i> = &vw11; |
| let vf112: u32 = arrayLength(&(*&buffer122)); |
| vw12[unconst_u32(1235498291)][unconst_u32(360960907)] = bool(pack4xU8(buffer122[arrayLength(&buffer122)][49][1].location_14)); |
| for (var ii7=0u; ii7<0x1000; ii7+=0x11) { buffer122[ii7][unconst_u32(1098942449)][unconst_u32(45583344)].location_14 ^= vec4u(atanh(vec4h(unconst_f16(4707.8), unconst_f16(7651.5), unconst_f16(6026.0), unconst_f16(2613.8)))); } |
| fn2(vec2u(u32(override22))); |
| buffer122[unconst_u32(176739997)][pack4xU8Clamp(buffer122[(*&buffer122)[unconst_u32(174599799)][unconst_u32(98307802)][unconst_u32(21380560)].location_14[3]][49][unconst_u32(776226576)].location_14)][pack4xU8(buffer122[unconst_u32(235156843)][49][unconst_u32(127039063)].location_14)].location_14 = buffer122[unconst_u32(904388758)][49][1].location_14; |
| let ptr53: ptr<storage, FragmentInput17, read_write> = &buffer122[arrayLength(&buffer122)][49][unconst_u32(365374182)]; |
| return out; |
| _ = override22; |
| _ = buffer122; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(2) @binding(7) var<storage, read_write> buffer123: array<array<array<array<array<f16, 23>, 1>, 2>, 4>>; |
| |
| struct VertexInput42 { |
| @location(6) location_6: vec4f, |
| @location(4) @interpolate(perspective) location_4: f16, |
| @location(9) @interpolate(flat) location_9: vec4f, |
| @location(3) location_3: vec2i, |
| } |
| |
| struct VertexInput40 { |
| @location(5) @interpolate(linear) location_5: vec4h, |
| } |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<storage, array<array<VertexOutput8, 26>>, read_write>, a1: texture_3d<i32>) -> array<bool, 1> { |
| var out: array<bool, 1>; |
| let ptr44: ptr<storage, array<VertexOutput8, 26>, read_write> = &(*a0)[unconst_i32(492379345)]; |
| let ptr45: ptr<storage, array<array<VertexOutput8, 26>>, read_write> = &(*a0); |
| let ptr46: ptr<function, bool> = &out[0]; |
| (*a0)[unconst_u32(390904018)][pack4xU8(vec4u((*ptr45)[unconst_u32(305783566)][25].position.xyyx))] = (*ptr45)[unconst_i32(76537222)][25]; |
| for (var jj11=0u; jj11<28; jj11++) { (*a0)[unconst_u32(1808939787)][jj11].position += vec4f(asin(vec2h(unconst_f16(2883.9), unconst_f16(7348.6))).gggg); } |
| let ptr47: ptr<storage, array<VertexOutput8, 26>, read_write> = &(*ptr44); |
| loop { |
| (*a0)[unconst_u32(1516831777)][unconst_u32(893022480)].position = (*a0)[unconst_u32(233207013)][25].position; |
| break; |
| } |
| let ptr48: ptr<storage, VertexOutput8, read_write> = &(*ptr45)[unconst_u32(955577496)][unconst_u32(342025124)]; |
| return out; |
| } |
| |
| struct FragmentInput18 { |
| @location(5) @interpolate(flat) location_5: vec2h, |
| @location(0) @interpolate(linear) location_0: vec4f, |
| @location(2) @interpolate(flat, sample) location_2: i32, |
| @location(6) location_6: vec4h, |
| @location(11) location_11: f32, |
| } |
| |
| struct FragmentOutput5 { |
| @location(6) @interpolate(perspective, first) location_6: vec2f, |
| @location(0) @interpolate(flat) location_0: vec2i, |
| } |
| |
| @group(2) @binding(241) var<storage, read_write> buffer124: array<array<VertexOutput8, 26>>; |
| |
| var<private> vp8 = modf(vec4h(4177.4, 11657.0, 5224.0, 4654.4)); |
| |
| struct FragmentInput20 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| /* used global variables: et13, tex10 */ |
| @must_use |
| fn fn4(a0: vec4<bool>) -> array<array<vec2u, 1>, 1> { |
| var out: array<array<vec2u, 1>, 1>; |
| var vf113 = fn2(out[unconst_u32(830391691)][0]); |
| vf113 *= vec2f(bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.2108), unconst_f32(0.02767e4))))); |
| vp8 = modf(bitcast<vec4h>(out[0][countLeadingZeros(unconst_u32(392813614))])); |
| vp8.fract = vec4h(f16(out[unconst_u32(51073278)][0][unconst_u32(550264703)])); |
| vp8 = modf(vec4h(f16(countLeadingZeros(unconst_u32(1874883716))))); |
| let ptr54: ptr<function, vec2u> = &out[unconst_u32(244182887)][unconst_u32(77719711)]; |
| var vf114: u32 = out[0][unconst_u32(1756574419)][unconst_u32(3153851)]; |
| vf113 = unpack2x16snorm(textureNumLevels(tex10)); |
| switch out[unconst_u32(1393198449)][0][unconst_u32(880094065)] { |
| case 108076507 { |
| let vf115: bool = (unconst_bool(true) && bool(out[unconst_u32(709880118)][unconst_u32(6674815)].y)); |
| break; |
| } |
| case 3425548035 { |
| var vf116: vec2f = tanh(vec2f(unconst_f32(0.5303), unconst_f32(0.1281))); |
| vp8.fract = vec4h(f16((bool(out[0][unconst_u32(2255158991)].y) || unconst_bool(false)))); |
| vp7.fract = vec4h(f16(smoothstep(unconst_f32(0.04851), unconst_f32(0.5499e17), unconst_f32(0.05618e-2)))); |
| var vf117: u32 = out[unconst_u32(1755070647)][0][unconst_u32(568215960)]; |
| let vf118: bool = (unconst_bool(true) || unconst_bool(false)); |
| } |
| case default, 278363102, 1681980301 { |
| out[unconst_u32(533094931)][unconst_u32(45228552)] *= out[unconst_u32(318724963)][0]; |
| vp8 = modf(vec4h(textureLoad(et13, vec2u(unconst_u32(523186458), unconst_u32(64854585))))); |
| vp7.whole = bitcast<vec4h>(out[0][0]); |
| if bool(ldexp(vec4f(unconst_f32(0.01281), unconst_f32(0.1022e35), unconst_f32(0.06823), unconst_f32(0.1473e-30)), vec4i(unconst_i32(223541499), unconst_i32(3029713), unconst_i32(683226940), unconst_i32(940667)))[1]) { |
| out[unconst_u32(338150028)][unconst_u32(1783038924)] &= vec2u((vec2i(unconst_i32(218617480), unconst_i32(108113107)) == vec2i(unconst_i32(69301972), unconst_i32(627205832)))); |
| vp8.fract = bitcast<vec4h>(textureDimensions(et13)); |
| _ = et13; |
| } |
| _ = et13; |
| } |
| } |
| return out; |
| _ = et13; |
| _ = tex10; |
| } |
| |
| /* used global variables: et13, tex10 */ |
| fn fn5(a0: array<array<bool, 1>, 24>) -> array<array<f16, 43>, 1> { |
| var out: array<array<f16, 43>, 1>; |
| vp8 = modf(vec4h(out[0][unconst_u32(688352499)])); |
| switch clamp(vec2u(unconst_u32(201586263), unconst_u32(315713783)), vec2u(unconst_u32(658993787), unconst_u32(970347029)), vec2u(unconst_u32(1411602737), unconst_u32(368581101)))[0] { |
| case 626361961, default: { |
| vp8 = modf(vec4h(out[0][42])); |
| vp7.fract = vec4h(f16(a0[unconst_u32(803034954)][unconst_u32(16274293)])); |
| out[unconst_u32(511350287)][unconst_u32(37395913)] = tanh(vec4h(f16(a0[23][0]))).w; |
| out[unconst_u32(1136230094)][unconst_u32(277140367)] = f16(a0[23][0]); |
| let ptr55: ptr<function, f16> = &out[unconst_u32(107343221)][42]; |
| var vf119: vec4h = tanh(vec4h(unconst_f16(14623.1), unconst_f16(-24984.2), unconst_f16(5248.0), unconst_f16(4042.1))); |
| } |
| } |
| _ = fn4(vec4<bool>(a0[23][0])); |
| var vf120: vec2f = floor(vec2f(f32(a0[23][0]))); |
| let vf121: vec2f = unpack2x16float(unconst_u32(481066857)); |
| let vf122: vec2i = (vec2i(unconst_i32(83691652), unconst_i32(-31890113)) | bitcast<vec2i>(tan(vec4h(unconst_f16(29569.6), unconst_f16(6036.4), unconst_f16(4551.0), unconst_f16(16068.8))))); |
| return out; |
| _ = et13; |
| _ = tex10; |
| } |
| |
| struct VertexInput44 { |
| @location(13) @interpolate(linear) location_13: f32, |
| } |
| |
| struct VertexOutput10 { |
| @location(15) location_15: vec4u, |
| @builtin(position) position: vec4f, |
| @location(2) @interpolate(flat) location_2: i32, |
| @location(0) @interpolate(linear, centroid) location_0: vec4h, |
| @location(10) @interpolate(flat, centroid) location_10: vec4i, |
| @location(13) location_13: u32, |
| @location(12) @interpolate(flat, either) location_12: vec2u, |
| @location(3) @interpolate(linear, centroid) location_3: vec4h, |
| @location(7) location_7: vec4f, |
| @location(6) @interpolate(flat, first) location_6: i32, |
| } |
| |
| struct FragmentInput17 { |
| @location(14) @interpolate(flat, centroid) location_14: vec4u, |
| } |
| |
| var<private> vp7 = modf(vec4h(5711.7, 7542.1, 7855.5, 2186.6)); |
| |
| @group(2) @binding(711) var sam5: sampler; |
| |
| struct VertexInput39 { |
| @location(2) location_2: f32, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw12: array<array<bool, 1>, 1>; |
| |
| struct T0 { |
| @align(16) f0: array<atomic<i32>>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(2) @binding(47) var tex10: texture_2d<f32>; |
| |
| struct VertexOutput9 { |
| @location(0) location_0: vec2i, |
| @location(12) location_12: vec2u, |
| @location(6) @interpolate(flat) location_6: i32, |
| @builtin(position) position: vec4f, |
| @location(4) @interpolate(flat, either) location_4: vec2i, |
| @location(10) @interpolate(flat, either) location_10: f32, |
| @location(5) location_5: vec4i, |
| @location(8) location_8: f32, |
| @location(11) @interpolate(linear, centroid) location_11: vec2h, |
| } |
| |
| /* used global variables: et13, sam5, st12, tex10 */ |
| @vertex |
| fn vertex10(@location(3) @interpolate(flat) location_3: i32, @location(9) location_9: vec4u, @location(6) location_6: vec2i, a3: VertexInput39, @builtin(vertex_index) vertex_index: u32, @builtin(instance_index) instance_index: u32, a6: VertexInput40, @location(8) @interpolate(linear) location_8: f32) -> VertexOutput8 { |
| var out: VertexOutput8; |
| var vf123 = fn5(array<array<bool, 1>, 24>(array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6.y)), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.x)), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.g)), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.x)), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6.r)), array<bool, 1>(bool(location_6.g)), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6[1])), array<bool, 1>(bool(location_6.r)), array<bool, 1>(bool(location_6.r)), array<bool, 1>(bool(location_6[0])), array<bool, 1>(bool(location_6[0])))); |
| vp7 = modf(vec4h(textureDimensions(st12).grgb.xwww.wxyx)); |
| let ptr56: ptr<private, vec4h> = &vp8.whole; |
| out.position = vec4f(f32( -unconst_i32(484812176))); |
| let vf124: f16 = length(unconst_f16(4221.4)); |
| while bool(textureNumLevels(tex10)) { |
| while bool(location_6.g) { |
| vp7 = modf(vec4h(f16(pack4x8snorm(vec4f(unconst_f32(0.1578e37), unconst_f32(0.04996e-12), unconst_f32(0.04413e31), unconst_f32(0.00417)))))); |
| break; |
| } |
| } |
| let vf125: vec2f = unpack2x16unorm(unconst_u32(353952407)); |
| fn1(); |
| return out; |
| _ = st12; |
| _ = et13; |
| _ = sam5; |
| _ = tex10; |
| } |
| |
| /* used global variables: et13 */ |
| @vertex |
| fn vertex11(@location(14) location_14: vec2h, @location(0) location_0: vec4f, a2: VertexInput41, @location(5) @interpolate(perspective) location_5: vec4f, a4: VertexInput42, a5: VertexInput43, @location(10) location_10: i32, a7: VertexInput44, @builtin(vertex_index) vertex_index: u32, @builtin(instance_index) instance_index: u32) -> VertexOutput9 { |
| var out: VertexOutput9; |
| out.location_8 = f32(unconst_f32(0.3659e18)); |
| return out; |
| _ = et13; |
| } |
| |
| /* used global variables: et12, et13, sam5, tex10 */ |
| @vertex @must_use |
| fn vertex12(a0: VertexInput45) -> VertexOutput10 { |
| var out: VertexOutput10; |
| _ = fn4(vec4<bool>(textureGather(521574961 % 4, tex10, sam5, vec2f(unconst_f32(0.3423e2), unconst_f32(0.07495e-23)), clamp(vec2i(408543955, 368837997), vec2i(-8), vec2i(7))).zzzx.xxyz.wzxw.xxzy)); |
| for (var it6=pack4x8snorm(out.location_7); it6<(pack4x8unorm(textureSampleBaseClampToEdge(et12, sam5, vec2f(unconst_f32(-0.01654e-9), unconst_f32(0.04638)))) & 0xfff); it6++) { |
| out.location_12 -= vec2u(textureSampleBaseClampToEdge(et13, sam5, vec2f(unconst_f32(0.04750e-6), unconst_f32(0.2664e10))).xz.gr.yy); |
| var vf126 = fn5(array<array<bool, 1>, 24>(array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[2])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[3])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).a)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[1])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[0])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).g)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[3])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[0])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).y)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).g)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).w)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).a)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).x)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).r)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).w)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[1])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).r)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[3])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).x)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).z)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[2])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001)))[2])), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).z)), array<bool, 1>(bool(textureLoad(et13, vec2u(unconst_u32(57114091), unconst_u32(445209001))).w)))); |
| loop { |
| var vf127: f32 = override22; |
| var vf128: vec4f = textureLoad(tex10, vec2i(i32(out.location_13)), out.location_2); |
| out.location_3 *= vec4h(f16(out.location_13)); |
| break; |
| _ = override22; |
| _ = tex10; |
| } |
| _ = override22; |
| _ = sam5; |
| _ = tex10; |
| _ = et13; |
| } |
| out.position *= unpack4x8unorm(out.location_15[unconst_u32(62124966)]); |
| loop { |
| out.location_13 *= u32(floor(unconst_f16(13832.9))); |
| vp8 = modf(vec4h(acos(vp8.whole[1]))); |
| while bool(abs(vec3u(unconst_u32(803908603), unconst_u32(131094337), unconst_u32(228481392)))[1]) { |
| let ptr57: ptr<private, vec4h> = &vp7.fract; |
| out.position += vec4f((*ptr57)); |
| fn5(array<array<bool, 1>, 24>(array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)), array<bool, 1>(bool(out.location_2)))); |
| return out; |
| _ = et13; |
| _ = tex10; |
| } |
| out.location_15 |= vec4u(u32((unconst_bool(false) && unconst_bool(true)))); |
| out.location_13 &= pack2x16snorm(unpack4x8snorm(u32((unconst_i32(107477387) <= unconst_i32(42550974)))).xw); |
| out.location_12 *= vec2u(a0.location_1.yz); |
| break; |
| _ = et13; |
| _ = tex10; |
| } |
| _ = sam5; |
| out.position += vec4f(a0.location_11); |
| return out; |
| _ = override22; |
| _ = et12; |
| _ = sam5; |
| _ = tex10; |
| _ = et13; |
| } |
| |
| /* used global variables: buffer122, buffer123, buffer124 */ |
| @fragment |
| fn fragment8(a0: FragmentInput17, @location(8) location_8: vec2i, @location(10) location_10: vec2f, @location(4) location_4: vec2u, @location(9) @interpolate(linear, sample) location_9: vec4h, a5: FragmentInput18, @location(15) location_15: vec4u, @builtin(position) position: vec4f, a8: FragmentInput19, @builtin(front_facing) front_facing: bool, a10: FragmentInput20) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| if bool(pack2x16float(vec2f(unconst_f32(0.1726e25), unconst_f32(0.1684)))) { |
| let ptr58: ptr<storage, array<f16, 23>, read_write> = &buffer123[arrayLength(&buffer123)][unconst_u32(464718955)][1][unconst_u32(254309519)]; |
| return out; |
| _ = buffer123; |
| } |
| let ptr59: ptr<storage, vec4u, read_write> = &buffer122[arrayLength(&buffer122)][49][unconst_u32(1167556732)].location_14; |
| for (var jj93=0u; jj93<6; jj93++) { buffer123[unconst_u32(442878489)][jj93][unconst_u32(1063958514)][unconst_u32(411118293)][unconst_u32(875610397)] *= f16((*&buffer124)[unconst_u32(969436973)][25].position.g); } |
| let ptr60: ptr<storage, FragmentInput17, read_write> = &buffer122[unconst_u32(12587965)][unconst_u32(95476728)][u32(buffer123[unconst_u32(1472764143)][3][1][unconst_u32(697803034)][22])]; |
| let ptr61: ptr<storage, vec4f, read_write> = &buffer124[unconst_u32(1119245505)][25].position; |
| return out; |
| _ = buffer124; |
| _ = buffer123; |
| _ = buffer122; |
| }`, |
| }); |
| let bindGroup63 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 3, resource: textureView0}, {binding: 1, resource: externalTexture7}], |
| }); |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let texture128 = device0.createTexture({size: [2, 2, 14], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer104, 576, 9); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let canvas5 = document.createElement('canvas'); |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let textureView149 = texture30.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup25, [0]); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup4, new Uint32Array(1726), 758, 1); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(565); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer60, 'uint16', 90, 10); |
| } catch {} |
| let videoFrame24 = new VideoFrame(videoFrame13, {timestamp: 0}); |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 26, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 30, visibility: 0, buffer: { type: 'storage', minBindingSize: 25, hasDynamicOffset: false }}, |
| { |
| binding: 115, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let texture129 = device0.createTexture({ |
| size: [390], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder6.setPipeline(pipeline13); |
| } catch {} |
| try { |
| commandEncoder108.copyTextureToTexture({ |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 12, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 25, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup64 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 11, resource: textureView29}, |
| {binding: 148, resource: {buffer: buffer110}}, |
| {binding: 15, resource: {buffer: buffer70}}, |
| {binding: 3, resource: textureView134}, |
| {binding: 220, resource: {buffer: buffer116}}, |
| {binding: 12, resource: textureView76}, |
| {binding: 1, resource: externalTexture22}, |
| {binding: 251, resource: {buffer: buffer81}}, |
| {binding: 141, resource: {buffer: buffer66}}, |
| {binding: 81, resource: externalTexture7}, |
| {binding: 4, resource: {buffer: buffer66, offset: 0}}, |
| {binding: 166, resource: textureView88}, |
| {binding: 2, resource: textureView97}, |
| {binding: 125, resource: textureView38}, |
| {binding: 152, resource: textureView90}, |
| {binding: 5, resource: {buffer: buffer34}}, |
| {binding: 0, resource: {buffer: buffer37, size: 776}}, |
| {binding: 6, resource: textureView0}, |
| {binding: 106, resource: {buffer: buffer116}}, |
| {binding: 86, resource: {buffer: buffer37}}, |
| ], |
| }); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, undefined, 0, 1_558_005_675); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 32, new DataView(new Uint8Array(25241).map((_, i) => i).buffer), 1427, 0); |
| } catch {} |
| let gpuCanvasContext9 = canvas5.getContext('webgpu'); |
| let texture130 = device0.createTexture({ |
| size: [195, 12, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup19, [0]); |
| } catch {} |
| let texture131 = device0.createTexture({ |
| size: [780], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let texture132 = gpuCanvasContext7.getCurrentTexture(); |
| let textureView150 = texture5.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer74, 'uint32', 4, 14); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 3, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(79).fill(53), /* required buffer size: 79 */ |
| {offset: 79, bytesPerRow: 141, rowsPerImage: 110}, {width: 26, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline27 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x2ecf8653}, |
| fragment: {module: shaderModule2, targets: [{format: 'r16sint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule9, |
| buffers: [ |
| { |
| arrayStride: 12, |
| stepMode: 'instance', |
| attributes: [{format: 'uint16x4', offset: 0, shaderLocation: 3}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let texture133 = device0.createTexture({size: [97, 60, 1], mipLevelCount: 4, format: 'r16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer104); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer65, 'uint32', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer5, 0, 98); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToBuffer(buffer11, 1880, buffer65, 4, 0); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 112, new Float32Array(5633).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7468)), 756, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 2, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas5 = new OffscreenCanvas(236, 181); |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| let renderPassEncoder20 = commandEncoder82.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView74, |
| depthSlice: 3, |
| clearValue: { r: 808.5, g: 495.6, b: -58.87, a: -246.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| renderBundleEncoder23.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder111.clearBuffer(buffer34, 16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 28, new DataView(new ArrayBuffer(52136)), 9229, 12); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup65 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer66}}]}); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let textureView151 = texture3.createView({dimension: '2d', baseArrayLayer: 0}); |
| let buffer127 = device0.createBuffer({size: 179, usage: GPUBufferUsage.STORAGE}); |
| let texture134 = device0.createTexture({ |
| size: [1560, 96, 1], |
| mipLevelCount: 7, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView152 = texture98.createView({}); |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup65, new Uint32Array(4326), 1_191, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(4, buffer111); |
| } catch {} |
| let bindGroup66 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer105, size: 24}}, |
| {binding: 43, resource: {buffer: buffer37}}, |
| {binding: 3, resource: textureView17}, |
| {binding: 58, resource: {buffer: buffer107}}, |
| ], |
| }); |
| let texture135 = device0.createTexture({ |
| size: [16, 24, 4], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup7, new Uint32Array(3224), 128, 1); |
| } catch {} |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder20.beginOcclusionQuery(717); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup0, new Uint32Array(2143), 190, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer106, 76, new Float32Array(2450).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.260)), 165, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 8, y: 789 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 141, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup67 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 3, resource: textureView17}, {binding: 1, resource: externalTexture5}], |
| }); |
| let buffer128 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder123 = device0.createCommandEncoder({}); |
| let texture136 = device0.createTexture({size: [4, 6, 1], sampleCount: 1, format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView153 = texture36.createView({}); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup13, new Uint32Array(3320), 198, 0); |
| } catch {} |
| try { |
| commandEncoder65.insertDebugMarker('\uea3d'); |
| } catch {} |
| let texture137 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16sint'], |
| }); |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 79.50, |
| }); |
| try { |
| renderPassEncoder20.setVertexBuffer(3, buffer82, 24); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(5, buffer59, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 24, new DataView(new Uint8Array(5641).map((_, i) => i).buffer), 58, 0); |
| } catch {} |
| let offscreenCanvas6 = new OffscreenCanvas(43, 205); |
| let buffer129 = device0.createBuffer({size: 8, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let textureView154 = texture69.createView({}); |
| try { |
| renderPassEncoder20.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer112, 'uint32', 48, 2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 36, new Float32Array(10314).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6825)), 160, 0); |
| } catch {} |
| let buffer130 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder124 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder4.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup44); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer74, 'uint32', 44, 0); |
| } catch {} |
| try { |
| commandEncoder116.copyTextureToTexture({ |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 33, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 190, y: 0, z: 8}, |
| aspect: 'all', |
| }, |
| {width: 438, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 116, new BigInt64Array(4850).map((_, i) => BigInt(i - 9)), 711, 0); |
| } catch {} |
| let buffer131 = device0.createBuffer({size: 424, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let texture138 = device0.createTexture({ |
| size: [32, 48, 8], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView155 = texture25.createView({baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| commandEncoder107.resolveQuerySet(querySet1, 26, 1, buffer71, 0); |
| } catch {} |
| let commandEncoder126 = device0.createCommandEncoder({}); |
| let texture139 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 1}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup48, new Uint32Array(2060), 92, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer1, 'uint32', 28, 34); |
| } catch {} |
| try { |
| await shaderModule5.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder76.clearBuffer(buffer56); |
| } catch {} |
| try { |
| commandEncoder77.resolveQuerySet(querySet1, 75, 7, buffer63, 0); |
| } catch {} |
| let imageData20 = new ImageData(20, 120); |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| let textureView156 = texture56.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder5.setBlendConstant({ r: 884.2, g: -17.48, b: -375.1, a: -569.8, }); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer93, 'uint16', 2, 42); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(2, bindGroup47, new Uint32Array(1704), 256, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(7, buffer35, 0, 0); |
| } catch {} |
| try { |
| commandEncoder119.resolveQuerySet(querySet0, 259, 0, buffer108, 0); |
| } catch {} |
| let imageData21 = new ImageData(72, 40); |
| try { |
| bindGroup60.label = '\u005d\u20c1\ucaa6\ubaf0\u026a\u2f09\u18f4\u{1f61e}'; |
| } catch {} |
| let autogeneratedBindGroupLayout12 = pipeline7.getBindGroupLayout(0); |
| let bindGroup68 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer75}}]}); |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| let texture140 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| sampleCount: 1, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup34, new Uint32Array(378), 9, 1); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let textureView157 = texture47.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup25, [0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer112, 'uint16', 40, 13); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline14); |
| } catch {} |
| try { |
| computePassEncoder21.insertDebugMarker('\ud810'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer101, 12, new Uint32Array(2633).map((_, i) => i * 3), 8, 0); |
| } catch {} |
| let pipeline28 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, entryPoint: 'compute6'}}); |
| try { |
| computePassEncoder4.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline14); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 116, new Float32Array(4113).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.266)), 183, 4); |
| } catch {} |
| let gpuCanvasContext10 = offscreenCanvas5.getContext('webgpu'); |
| let bindGroup69 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 84, resource: {buffer: buffer107}}, |
| {binding: 6, resource: textureView44}, |
| {binding: 255, resource: {buffer: buffer37, size: 684}}, |
| {binding: 201, resource: {buffer: buffer116, offset: 0}}, |
| {binding: 2, resource: {buffer: buffer82}}, |
| {binding: 264, resource: textureView36}, |
| {binding: 269, resource: textureView12}, |
| {binding: 3, resource: {buffer: buffer60}}, |
| {binding: 33, resource: textureView26}, |
| {binding: 386, resource: textureView17}, |
| {binding: 148, resource: textureView36}, |
| {binding: 211, resource: {buffer: buffer116}}, |
| {binding: 0, resource: {buffer: buffer79}}, |
| {binding: 9, resource: {buffer: buffer37}}, |
| {binding: 219, resource: textureView3}, |
| {binding: 40, resource: externalTexture13}, |
| {binding: 7, resource: textureView2}, |
| {binding: 5, resource: textureView149}, |
| {binding: 210, resource: {buffer: buffer21, size: 1612}}, |
| {binding: 284, resource: textureView155}, |
| {binding: 45, resource: externalTexture11}, |
| {binding: 11, resource: {buffer: buffer21, offset: 0, size: 3136}}, |
| {binding: 117, resource: {buffer: buffer21, size: 2332}}, |
| ], |
| }); |
| let buffer132 = device0.createBuffer({size: 384, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let commandBuffer2 = commandEncoder12.finish(); |
| let externalTexture27 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup27, [0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 44, new Uint32Array(11098).map((_, i) => i * 8), 1318, 0); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 557, resource: externalTexture6}, |
| {binding: 176, resource: {buffer: buffer107, offset: 256}}, |
| {binding: 0, resource: {buffer: buffer120, size: 16}}, |
| ], |
| }); |
| let buffer133 = device0.createBuffer({ |
| size: 50, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup12, new Uint32Array(3563), 55, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer89, 0, 83); |
| } catch {} |
| let textureView158 = texture68.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer132, 0); |
| } catch {} |
| try { |
| commandEncoder47.copyBufferToTexture({ |
| /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 496 */ |
| offset: 496, |
| bytesPerRow: 9216, |
| rowsPerImage: 128, |
| buffer: buffer11, |
| }, { |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder8.insertDebugMarker('\u00a3'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 12, new Float32Array(5234).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7711)), 2421, 8); |
| } catch {} |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer107, 'uint32', 2_968); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(0, buffer19); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline20); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 27, y: 14 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 103, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 28, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData22 = new ImageData(20, 108); |
| let bindGroup71 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout10, |
| entries: [{binding: 10, resource: {buffer: buffer127, size: 96}}], |
| }); |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| let texture141 = device0.createTexture({ |
| size: {width: 32, height: 48, depthOrArrayLayers: 8}, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture142 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView159 = texture85.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder18.draw(535, 0, 155_146_320); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndexed(2, 0, 0, 21_270_851); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndexedIndirect(buffer4, 8); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer107, 'uint32', 12, 581); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup47, new Uint32Array(522), 64, 0); |
| } catch {} |
| let commandEncoder132 = device0.createCommandEncoder({}); |
| let texture143 = device0.createTexture({ |
| size: [390, 24, 15], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView160 = texture9.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder18.drawIndexedIndirect(buffer45, 8); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer53, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(7, buffer5, 0, 130); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView161 = texture141.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder18.drawIndexedIndirect(buffer133, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer71, 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer55, 'uint16', 22, 2_451); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer130, 0, new DataView(new Uint8Array(195).map((_, i) => i).buffer), 21, 0); |
| } catch {} |
| let pipelineLayout4 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout11, autogeneratedBindGroupLayout6, veryExplicitBindGroupLayout9], |
| }); |
| let commandEncoder133 = device0.createCommandEncoder({}); |
| let texture144 = device0.createTexture({ |
| size: {width: 16, height: 24, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup17, [0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup56, new Uint32Array(420), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndexedIndirect(buffer35, 16); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndirect(buffer37, 108); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer118); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup72 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 176, resource: {buffer: buffer107, offset: 0}}, |
| {binding: 557, resource: externalTexture16}, |
| {binding: 0, resource: {buffer: buffer70}}, |
| ], |
| }); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let texture145 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView162 = texture131.createView({dimension: '1d', format: 'r16sint'}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup29, new Uint32Array(3198), 217, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup35, []); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup59, new Uint32Array(2316), 164, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup18, new Uint32Array(2165), 91, 0); |
| } catch {} |
| try { |
| buffer96.unmap(); |
| } catch {} |
| try { |
| computePassEncoder23.insertDebugMarker('\ubc9f'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 36, new DataView(new Uint8Array(27604).map((_, i) => i).buffer), 16929, 20); |
| } catch {} |
| let pipeline29 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1'}}); |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(60); }; |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let textureView163 = texture144.createView({dimension: '2d-array'}); |
| let textureView164 = texture62.createView({}); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup2, new Uint32Array(508), 162, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline14); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let texture146 = device0.createTexture({ |
| size: [8, 12, 3], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup69, [0, 0]); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup49, new Uint32Array(255), 50, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer19, 'uint16', 16, 15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 8, new Uint32Array(348).map((_, i) => i * 3), 65, 12); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer134 = device0.createBuffer({size: 45, usage: GPUBufferUsage.MAP_WRITE}); |
| let textureView165 = texture65.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer93, 'uint32', 0, 13); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup59, []); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 40, new Float32Array(27588).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.217)), 2919, 0); |
| } catch {} |
| let texture147 = device0.createTexture({ |
| size: [780, 480, 5], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView166 = texture113.createView({}); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer65, 'uint16', 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer120, 'uint32', 12, 79); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.prepend(img4); |
| let buffer135 = device0.createBuffer({size: 480, usage: GPUBufferUsage.INDIRECT}); |
| let textureView167 = texture31.createView({}); |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup5, new Uint32Array(860), 83, 1); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline16); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let imageData23 = new ImageData(24, 4); |
| let bindGroup73 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer116}}, |
| {binding: 3, resource: textureView3}, |
| {binding: 58, resource: {buffer: buffer116}}, |
| {binding: 6, resource: {buffer: buffer116}}, |
| ], |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer69, 'uint32', 20, 92); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer107, 'uint32', 188, 331); |
| } catch {} |
| let pipeline30 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}}); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 10, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 384, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture148 = device0.createTexture({size: [780, 480, 238], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView168 = texture25.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer104, 0); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let autogeneratedBindGroupLayout13 = pipeline12.getBindGroupLayout(0); |
| let texture149 = device0.createTexture({size: [2, 2, 14], format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder19.beginOcclusionQuery(129); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline27); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 8, new DataView(new ArrayBuffer(8520)), 519, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture136, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(175).fill(166), /* required buffer size: 175 */ |
| {offset: 175}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup25, new Uint32Array(589), 18, 1); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 1936}}, |
| {binding: 6, resource: {buffer: buffer127, size: 36}}, |
| ], |
| }); |
| let buffer136 = device0.createBuffer({ |
| size: 184, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder135 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder2.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer9); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer93, 'uint16', 6, 31); |
| } catch {} |
| try { |
| buffer33.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture104, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(55_639).fill(184), /* required buffer size: 55_639 */ |
| {offset: 199, bytesPerRow: 28, rowsPerImage: 36}, {width: 0, height: 0, depthOrArrayLayers: 56}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 9, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer137 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder136 = device0.createCommandEncoder({}); |
| let texture150 = gpuCanvasContext7.getCurrentTexture(); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup71, new Uint32Array(2277), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup23, new Uint32Array(8437), 3_655, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer137, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer71, 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(6, buffer118, 0, 441); |
| } catch {} |
| try { |
| await shaderModule9.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder74.copyBufferToTexture({ |
| /* bytesInLastRow: 392 widthInBlocks: 98 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1580 */ |
| offset: 1580, |
| bytesPerRow: 12800, |
| buffer: buffer118, |
| }, { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 110, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 98, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToBuffer({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 71, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2258 widthInBlocks: 1129 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1004 */ |
| offset: 1004, |
| bytesPerRow: 12800, |
| buffer: buffer56, |
| }, {width: 1129, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img2); |
| let textureView169 = texture145.createView({dimension: '2d-array'}); |
| let texture151 = device0.createTexture({ |
| size: [195, 120, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(2, buffer132); |
| } catch {} |
| try { |
| await buffer7.mapAsync(GPUMapMode.READ, 8, 0); |
| } catch {} |
| try { |
| commandEncoder114.copyBufferToTexture({ |
| /* bytesInLastRow: 494 widthInBlocks: 247 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2090 */ |
| offset: 2090, |
| bytesPerRow: 512, |
| buffer: buffer118, |
| }, { |
| texture: texture147, |
| mipLevel: 0, |
| origin: {x: 347, y: 280, z: 0}, |
| aspect: 'all', |
| }, {width: 247, height: 36, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.label = '\u0f43\ucda5\u0486\uf7b4'; |
| } catch {} |
| let bindGroup75 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer37}}, |
| {binding: 2, resource: textureView97}, |
| {binding: 86, resource: {buffer: buffer116}}, |
| {binding: 152, resource: textureView87}, |
| {binding: 5, resource: {buffer: buffer133, size: 16}}, |
| {binding: 125, resource: textureView26}, |
| {binding: 166, resource: textureView138}, |
| {binding: 220, resource: {buffer: buffer120}}, |
| {binding: 141, resource: {buffer: buffer116}}, |
| {binding: 81, resource: externalTexture22}, |
| {binding: 11, resource: textureView38}, |
| {binding: 12, resource: textureView76}, |
| {binding: 6, resource: textureView17}, |
| {binding: 1, resource: externalTexture21}, |
| {binding: 4, resource: {buffer: buffer107}}, |
| {binding: 3, resource: textureView80}, |
| {binding: 148, resource: {buffer: buffer130}}, |
| {binding: 251, resource: {buffer: buffer32}}, |
| {binding: 15, resource: {buffer: buffer37, size: 312}}, |
| {binding: 106, resource: {buffer: buffer21, offset: 256, size: 1264}}, |
| ], |
| }); |
| let buffer138 = device0.createBuffer({size: 364, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView170 = texture105.createView({baseMipLevel: 0}); |
| let textureView171 = texture65.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup38, new Uint32Array(1463), 174, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame24, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 64, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline31 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment1', |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule8, |
| entryPoint: 'vertex8', |
| buffers: [ |
| { |
| arrayStride: 340, |
| attributes: [ |
| {format: 'snorm16x2', offset: 16, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 10}, |
| {format: 'sint32', offset: 16, shaderLocation: 12}, |
| {format: 'uint32x3', offset: 40, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 44, shaderLocation: 4}, |
| {format: 'snorm8x2', offset: 52, shaderLocation: 5}, |
| {format: 'unorm8x2', offset: 6, shaderLocation: 2}, |
| {format: 'unorm16x2', offset: 40, shaderLocation: 3}, |
| {format: 'uint16x2', offset: 64, shaderLocation: 1}, |
| {format: 'unorm16x4', offset: 4, shaderLocation: 15}, |
| {format: 'uint8x2', offset: 190, shaderLocation: 8}, |
| {format: 'sint8x2', offset: 42, shaderLocation: 6}, |
| {format: 'uint32', offset: 20, shaderLocation: 13}, |
| {format: 'unorm8x2', offset: 6, shaderLocation: 7}, |
| ], |
| }, |
| {arrayStride: 16, attributes: [{format: 'uint16x2', offset: 0, shaderLocation: 0}]}, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'back'}, |
| }); |
| let videoFrame25 = new VideoFrame(videoFrame9, {timestamp: 0}); |
| let buffer139 = device0.createBuffer({size: 304, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup3, new Uint32Array(554), 54, 1); |
| } catch {} |
| let pipeline32 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule5, constants: {}}}); |
| let promise18 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| targets: [{ |
| format: 'rg8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule8, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| attributes: [ |
| {format: 'sint16x4', offset: 0, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 1}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 4}, |
| {format: 'float16x4', offset: 0, shaderLocation: 11}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 4, shaderLocation: 7}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 5}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 9}, |
| {format: 'float32x3', offset: 0, shaderLocation: 10}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| { |
| arrayStride: 44, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x4', offset: 8, shaderLocation: 3}, |
| {format: 'uint16x2', offset: 4, shaderLocation: 0}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 6}, |
| {format: 'float32x2', offset: 8, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 60, |
| stepMode: 'vertex', |
| attributes: [{format: 'float32x3', offset: 8, shaderLocation: 15}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', unclippedDepth: true}, |
| }); |
| let imageData24 = new ImageData(20, 12); |
| let texture152 = device0.createTexture({ |
| size: {width: 32, height: 48, depthOrArrayLayers: 8}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup14, new Uint32Array(1799), 814, 1); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(4, buffer68, 0); |
| } catch {} |
| try { |
| await buffer46.mapAsync(GPUMapMode.READ, 0, 12); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(img4); |
| await gc(); |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup52, new Uint32Array(909), 10, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(0, buffer139); |
| } catch {} |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer1, 'uint32', 140, 85); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer53, 'uint32', 0, 1); |
| } catch {} |
| try { |
| commandEncoder62.insertDebugMarker('\uf98e'); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 1, y: 14, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(113).fill(182), /* required buffer size: 113 */ |
| {offset: 113, bytesPerRow: 48}, {width: 6, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup76 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: []}); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let externalTexture28 = device0.importExternalTexture({source: videoFrame25, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup47); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToTexture({ |
| /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2164 */ |
| offset: 2164, |
| rowsPerImage: 125, |
| buffer: buffer118, |
| }, { |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 0, new DataView(new ArrayBuffer(1992)), 140, 4); |
| } catch {} |
| let buffer140 = device0.createBuffer({size: 112, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(3, buffer96, 0); |
| } catch {} |
| try { |
| commandEncoder118.copyBufferToTexture({ |
| /* bytesInLastRow: 76 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 194 */ |
| offset: 194, |
| bytesPerRow: 70144, |
| buffer: buffer76, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 38, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 292, new BigInt64Array(14202).map((_, i) => BigInt(i - 7)), 2521, 28); |
| } catch {} |
| let buffer141 = device0.createBuffer({ |
| size: 240, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView172 = texture45.createView({baseArrayLayer: 3, arrayLayerCount: 1}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup76, new Uint32Array(109), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer111, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer131, 'uint32', 280, 4); |
| } catch {} |
| let textureView173 = texture144.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup25, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer136, 'uint32', 8, 3); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline31); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer136, 0, new DataView(new ArrayBuffer(62968)), 1223, 0); |
| } catch {} |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline14); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup22, new Uint32Array(1431), 314, 1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup47, new Uint32Array(2056), 15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(7, buffer136); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer142 = device0.createBuffer({size: 140, usage: GPUBufferUsage.COPY_SRC}); |
| let textureView174 = texture50.createView({baseMipLevel: 0}); |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup41, new Uint32Array(32), 7, 0); |
| } catch {} |
| canvas5.width = 152; |
| let commandEncoder141 = device0.createCommandEncoder(); |
| let commandBuffer3 = commandEncoder88.finish(); |
| let sampler23 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMinClamp: 29.43}); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer19, 'uint16', 12, 42); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer96, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup29, new Uint32Array(129), 42, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 130, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| offscreenCanvas1.height = 112; |
| let commandEncoder142 = device0.createCommandEncoder(); |
| let textureView175 = texture111.createView({mipLevelCount: 1}); |
| let computePassEncoder24 = commandEncoder107.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 182}}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup42, new Uint32Array(437), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer137, 'uint16', 2, 6); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet0, 115, 0, buffer70, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }}, |
| {binding: 32, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 48, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 184, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 365, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }, |
| ], |
| }); |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup38, new Uint32Array(508), 118, 0); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline9); |
| } catch {} |
| try { |
| commandEncoder43.copyTextureToBuffer({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 844 */ |
| offset: 844, |
| bytesPerRow: 2304, |
| buffer: buffer91, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder12.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer19, 'uint16', 0, 25); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer131, 0, 66); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer118, 'uint16', 1_796, 362); |
| } catch {} |
| let gpuCanvasContext11 = offscreenCanvas6.getContext('webgpu'); |
| let textureView176 = texture59.createView({dimension: '2d-array', format: 'rg8sint', mipLevelCount: 1}); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup22, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(6, buffer131, 156, 159); |
| } catch {} |
| await gc(); |
| let buffer143 = device0.createBuffer({ |
| size: 44, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let texture153 = device0.createTexture({ |
| size: [780, 48, 366], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup76, new Uint32Array(1135), 622, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(2, bindGroup6, new Uint32Array(247), 32, 1); |
| } catch {} |
| document.body.prepend(img0); |
| let commandEncoder145 = device0.createCommandEncoder({label: '\u{1ff6c}\u0b5c\u{1fc20}\u1d4b\ua10c\u{1f9fe}'}); |
| let texture154 = device0.createTexture({ |
| size: [780], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder25 = commandEncoder110.beginComputePass({timestampWrites: {querySet: querySet0, endOfPassWriteIndex: 123}}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup6, new Uint32Array(522), 45, 1); |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup23, new Uint32Array(867), 45, 0); |
| } catch {} |
| try { |
| buffer90.unmap(); |
| } catch {} |
| let bindGroup77 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 184, resource: {buffer: buffer116}}, |
| {binding: 5, resource: sampler22}, |
| {binding: 0, resource: {buffer: buffer56}}, |
| {binding: 32, resource: externalTexture23}, |
| {binding: 48, resource: textureView17}, |
| {binding: 1, resource: sampler21}, |
| {binding: 365, resource: textureView170}, |
| ], |
| }); |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 264}); |
| let textureView177 = texture27.createView({dimension: '3d'}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline14); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame17, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup78 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 32, resource: externalTexture8}, |
| {binding: 1, resource: sampler1}, |
| {binding: 365, resource: textureView170}, |
| {binding: 5, resource: sampler4}, |
| {binding: 0, resource: {buffer: buffer107}}, |
| {binding: 48, resource: textureView0}, |
| {binding: 184, resource: {buffer: buffer70}}, |
| ], |
| }); |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder23.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup14, new Uint32Array(1560), 166, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer69, 'uint32', 72, 13); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(1, buffer136, 0, 50); |
| } catch {} |
| try { |
| commandEncoder138.copyTextureToBuffer({ |
| texture: texture142, |
| mipLevel: 0, |
| origin: {x: 3, y: 12, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 258 */ |
| offset: 258, |
| bytesPerRow: 768, |
| buffer: buffer56, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData21, |
| origin: { x: 9, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 15, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 13, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte240m', transfer: 'bt2020_12bit'} }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer93, 'uint32', 4, 20); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline31); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline33 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| await gc(); |
| let buffer144 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder147 = device0.createCommandEncoder(); |
| let texture155 = device0.createTexture({ |
| size: [16, 24, 4], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup76, new Uint32Array(1612), 159, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer82, 0, 70); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToTexture({ |
| texture: texture119, |
| mipLevel: 0, |
| origin: {x: 2, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| let textureView178 = texture54.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup13, new Uint32Array(6346), 34, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 924, new Float32Array(1552).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4196)), 398); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 3, y: 17, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(19).fill(131), /* required buffer size: 19 */ |
| {offset: 19, bytesPerRow: 164}, {width: 60, height: 82, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler24 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.35, |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer104, 0, 70); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer107, 'uint16', 1_118, 227); |
| } catch {} |
| let bindGroup79 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 3, resource: textureView0}, {binding: 1, resource: externalTexture19}], |
| }); |
| let buffer145 = device0.createBuffer({size: 128, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let textureView179 = texture49.createView({dimension: '2d-array'}); |
| let texture156 = device0.createTexture({ |
| size: [195, 12, 1], |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView180 = texture85.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer108); |
| } catch {} |
| let pipeline34 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute2'}}); |
| try { |
| await promise19; |
| } catch {} |
| await gc(); |
| let buffer146 = device0.createBuffer({size: 148, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let textureView181 = texture127.createView({dimension: '2d-array'}); |
| let texture157 = device0.createTexture({ |
| label: '\u86d3\u{1fbde}\u97dd', |
| size: {width: 4, height: 6, depthOrArrayLayers: 32}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup14, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(2, buffer107, 0, 498); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let buffer147 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_SRC}); |
| let commandEncoder150 = device0.createCommandEncoder({}); |
| let texture158 = device0.createTexture({ |
| size: [32, 48, 1], |
| format: 'astc-8x8-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture159 = device0.createTexture({ |
| size: [195], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder20.beginOcclusionQuery(835); |
| } catch {} |
| try { |
| renderPassEncoder20.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup36, [0]); |
| } catch {} |
| try { |
| commandEncoder89.copyTextureToTexture({ |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder109.resolveQuerySet(querySet2, 5, 5, buffer76, 0); |
| } catch {} |
| let commandEncoder151 = device0.createCommandEncoder({}); |
| let textureView182 = texture153.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder16.setPipeline(pipeline20); |
| } catch {} |
| let arrayBuffer8 = buffer143.getMappedRange(16); |
| try { |
| device0.queue.writeBuffer(buffer76, 0, new Float32Array(30661).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.187)), 7065, 0); |
| } catch {} |
| let shaderModule11 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| struct FragmentInput23 { |
| @location(4) location_4: f16, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @group(0) @binding(58) var<storage, read_write> buffer150: array<array<array<array<array<f16, 12>, 4>, 2>, 3>>; |
| |
| struct ComputeInput11 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| struct FragmentInput25 { |
| @location(12) @interpolate(flat, centroid) location_12: vec2u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentInput21 { |
| @location(13) @interpolate(flat, either) location_13: i32, |
| @location(7) @interpolate(linear, center) location_7: f16, |
| @invariant @builtin(position) position: vec4f, |
| } |
| |
| @group(0) @binding(6) var<storage, read_write> buffer148: array<vec4f>; |
| |
| struct ComputeInput12 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| struct FragmentInput26 { |
| @location(1) location_1: i32, |
| } |
| |
| struct T2 { |
| f0: array<vec2<bool>>, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T4 { |
| f0: array<u32>, |
| } |
| |
| struct FragmentInput22 { |
| @builtin(sample_index) sample_index: u32, |
| @location(10) location_10: vec2u, |
| @location(5) @interpolate(flat, center) location_5: vec4u, |
| } |
| |
| struct T1 { |
| f0: array<vec4f>, |
| } |
| |
| @group(0) @binding(43) var<uniform> buffer149: array<vec4u, 1>; |
| |
| struct FragmentOutput6 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(0) @interpolate(flat, center) location_0: i32, |
| } |
| |
| struct FragmentInput24 { |
| @location(8) location_8: i32, |
| } |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| var<workgroup> vw13: atomic<u32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| @size(104) f0: array<array<array<array<vec4i, 1>, 1>, 6>, 1>, |
| } |
| |
| /* used global variables: buffer149 */ |
| @vertex |
| fn vertex13() -> @builtin(position) vec4f { |
| var out: vec4f; |
| let vf129: vec4h = floor(vec4h(unconst_f16(19199.0), unconst_f16(2167.3), unconst_f16(598.0), unconst_f16(3139.8))); |
| var vf130: vec4h = (vec4h(unconst_f16(41471.3), unconst_f16(-13055.7), unconst_f16(30836.6), unconst_f16(2689.2)) % unconst_f16(8492.1)); |
| let vf131: u32 = buffer149[0][unconst_u32(196788037)]; |
| let vf132: vec4<bool> = (vec4h(unconst_f16(1497.4), unconst_f16(58642.9), unconst_f16(7151.0), unconst_f16(5792.3)) > vec4h(unconst_f16(17744.5), unconst_f16(22221.3), unconst_f16(10938.6), unconst_f16(15722.8))); |
| return out; |
| _ = buffer149; |
| } |
| |
| /* used global variables: buffer148 */ |
| @fragment |
| fn fragment9() -> @location(200) @interpolate(perspective) i32 { |
| var out: i32; |
| var vf133: vec3h = normalize(vec3h(unconst_f16(14812.0), unconst_f16(9815.9), unconst_f16(4124.2))); |
| var vf134: f32 = (*&buffer148)[unconst_u32(302583652)][unconst_u32(491742538)]; |
| if bool(pack4xI8(bitcast<vec4i>((*&buffer148)[unconst_i32(158046276)].rrbb))) { |
| out = i32((*&buffer148)[arrayLength(&(*&buffer148)) - 1][1]); |
| buffer148[unconst_u32(166993717)] -= (*&buffer148)[pack4x8snorm(buffer148[unconst_i32(132989551)])]; |
| buffer148[unconst_u32(842554517)] = vec4f(f32(any(unconst_bool(false)))); |
| let vf135: u32 = pack2x16float(vec2f(unconst_f32(0.08346), unconst_f32(0.01098))); |
| return out; |
| _ = buffer148; |
| } |
| vf134 += buffer148[unconst_u32(2415636278)][2]; |
| buffer148[unconst_u32(231080225)] *= vec4f(exp(vec2h(unconst_f16(6742.3), unconst_f16(18722.2))).rgrr.xxwy); |
| let ptr62: ptr<storage, vec4f, read_write> = &(*&buffer148)[u32(buffer148[arrayLength(&buffer148)].a)]; |
| var vf136: vec4f = mix(vec4f(unconst_f32(-0.04883), unconst_f32(0.1386), unconst_f32(0.00339e-26), unconst_f32(0.1571e-10)), vec4f(unconst_f32(0.06551e7), unconst_f32(0.1455), unconst_f32(0.08652), unconst_f32(0.2784e-34)), (*&buffer148)[arrayLength(&(*&buffer148))]); |
| var vf137: vec3f = floor(vec3f(unconst_f32(0.1611), unconst_f32(0.07655), unconst_f32(0.1068e-37))); |
| vf134 = buffer148[unconst_u32(1997415291)][unconst_u32(455359402)]; |
| let vf138: vec3f = floor(vec3f(unconst_f32(0.1764), unconst_f32(0.4967e9), unconst_f32(0.3764))); |
| vf134 = f32(all((vec2u(unconst_u32(865431499), unconst_u32(562895858)) != vec2u(unconst_u32(182648567), unconst_u32(736703026))))); |
| return out; |
| _ = buffer148; |
| } |
| |
| /* used global variables: buffer148 */ |
| @fragment |
| fn fragment10(@location(11) location_11: vec4h, a1: FragmentInput21, @location(14) location_14: i32, @location(9) @interpolate(linear) location_9: vec2h, a4: FragmentInput22, a5: FragmentInput23, a6: FragmentInput24, a7: FragmentInput25, a8: FragmentInput26, @location(3) @interpolate(flat, centroid) location_3: vec2i) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| buffer148[unconst_u32(970581037)] -= unpack4x8unorm(a7.location_12[unconst_u32(569743519)]); |
| let vf139: vec3h = select(vec3h(unconst_f16(14820.9), unconst_f16(-5140.4), unconst_f16(12614.7)), vec3h(unconst_f16(3997.2), unconst_f16(1341.9), unconst_f16(1553.3)), unconst_bool(true)); |
| let vf140: vec4u = a4.location_5; |
| var vf141: u32 = a4.sample_index; |
| return out; |
| _ = buffer148; |
| } |
| |
| /* used global variables: buffer148, buffer149, buffer150 */ |
| @compute @workgroup_size(4, 1, 1) |
| fn compute9(a0: ComputeInput11, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(global_invocation_id) global_invocation_id: vec3u, a4: ComputeInput12) { |
| let ptr63: ptr<storage, f16, read_write> = &(*&buffer150)[unconst_u32(3298911790)][unconst_u32(314762945)][1][unconst_u32(178023975)][11]; |
| buffer148[unconst_u32(14337052)] = vec4f(bitcast<f32>(arrayLength(&(*&buffer150)))); |
| let ptr64: ptr<storage, f16, read_write> = &(*&buffer150)[u32((*&buffer150)[arrayLength(&(*&buffer150))][unconst_u32(634643327)][1][unconst_u32(181017172)][unconst_u32(2503035532)])][2][1][unconst_u32(243242339)][unconst_u32(82657804)]; |
| let ptr65: ptr<uniform, vec4u> = &(*&buffer149)[u32((*&buffer150)[unconst_i32(474804814)][2][1][3][11])]; |
| for (var jj48=0u; jj48<5; jj48++) { buffer150[unconst_u32(980817519)][jj48][unconst_u32(529002089)][unconst_u32(17410122)][unconst_u32(18611727)] = vec4h((*ptr65).yyyy).r; } |
| let ptr66: ptr<storage, f16, read_write> = &(*&buffer150)[unconst_u32(788813709)][u32(buffer150[unconst_u32(375843179)][unconst_u32(3848579496)][u32(buffer150[unconst_u32(86962486)][unconst_u32(668139833)][unconst_u32(195718206)][3][11])][3][unconst_u32(1591934726)])][1][unconst_u32(265181609)][unconst_u32(626930598)]; |
| let ptr67: ptr<storage, f16, read_write> = &buffer150[unconst_u32(670469003)][2][1][3][unconst_u32(668771050)]; |
| atomicCompareExchangeWeak(&vw13, unconst_u32(1827201006), unconst_u32(463310173)); |
| _ = buffer148; |
| _ = buffer149; |
| _ = buffer150; |
| }`, |
| }); |
| let bindGroup80 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 3, resource: textureView17}, {binding: 1, resource: externalTexture3}], |
| }); |
| let texture160 = device0.createTexture({ |
| size: [390], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.27, |
| compare: 'greater', |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer90, 'uint16', 74, 211); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder102.resolveQuerySet(querySet1, 5, 2, buffer90, 0); |
| } catch {} |
| let buffer151 = device0.createBuffer({size: 31568, usage: GPUBufferUsage.INDIRECT}); |
| let texture161 = device0.createTexture({ |
| size: [16], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView183 = texture110.createView({label: '\u35a4\u0db9\u6d83\u071d\u{1fbec}\u93eb', mipLevelCount: 1}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup62); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup6, new Uint32Array(64), 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(3, bindGroup11, new Uint32Array(1004), 25, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 24, new Float32Array(17611).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.5062)), 4955, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas2); |
| let texture162 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| format: 'astc-5x4-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let arrayBuffer9 = buffer143.getMappedRange(0, 0); |
| try { |
| buffer96.unmap(); |
| } catch {} |
| document.body.prepend(img3); |
| let buffer152 = device0.createBuffer({size: 40, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let texture163 = device0.createTexture({ |
| size: [195, 12, 1], |
| mipLevelCount: 1, |
| format: 'r8snorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture164 = device0.createTexture({size: {width: 4}, mipLevelCount: 1, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_SRC}); |
| let renderPassEncoder21 = commandEncoder148.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView33, |
| clearValue: { r: 601.7, g: 238.1, b: -210.6, a: 30.16, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 624318024, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup35, new Uint32Array(683), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer118, 0, 4); |
| } catch {} |
| try { |
| commandEncoder94.clearBuffer(buffer129); |
| } catch {} |
| let pipeline35 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {5_373: 1}}}); |
| let commandEncoder152 = device0.createCommandEncoder({}); |
| let texture165 = device0.createTexture({ |
| size: [16, 24, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'astc-8x6-unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture166 = device0.createTexture({size: {width: 195}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView184 = texture31.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup75, [0, 0]); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(2670), 415, 1); |
| } catch {} |
| try { |
| commandEncoder145.clearBuffer(buffer76); |
| } catch {} |
| document.body.append(img1); |
| let commandEncoder153 = device0.createCommandEncoder({}); |
| let textureView185 = texture161.createView({}); |
| let texture167 = device0.createTexture({ |
| size: [390, 240, 1], |
| mipLevelCount: 3, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView186 = texture127.createView({baseMipLevel: 0}); |
| let externalTexture29 = device0.importExternalTexture({source: videoFrame12}); |
| try { |
| commandEncoder99.copyTextureToBuffer({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3302 */ |
| offset: 3302, |
| bytesPerRow: 24064, |
| buffer: buffer91, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer75, 92, new Uint32Array(5512).map((_, i) => i * 3), 103, 12); |
| } catch {} |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteRp431', transfer: 'hlg'} }); |
| let buffer153 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder154 = device0.createCommandEncoder(); |
| let texture168 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture169 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup75, new Uint32Array(1575), 686, 2); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup74, new Uint32Array(732), 330, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(5, buffer152, 0, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 0, y: 21 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture170 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture171 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView187 = texture170.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder8.drawIndirect(buffer110, 40); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer112, 'uint16', 32, 25); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup9, new Uint32Array(4), 0, 0); |
| } catch {} |
| try { |
| commandEncoder37.copyBufferToTexture({ |
| /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 248 */ |
| offset: 248, |
| bytesPerRow: 1280, |
| buffer: buffer147, |
| }, { |
| texture: texture55, |
| mipLevel: 3, |
| origin: {x: 16, y: 5, z: 0}, |
| aspect: 'all', |
| }, {width: 9, height: 36, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline36 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {5_373: 1}}}); |
| let buffer154 = device0.createBuffer({ |
| size: 276, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let texture172 = device0.createTexture({ |
| size: [780, 48, 1], |
| mipLevelCount: 2, |
| format: 'astc-12x12-unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView188 = texture158.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup35, new Uint32Array(1893), 94, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer55, 3_780); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer54, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup67, new Uint32Array(6573), 1_577, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer112, 'uint32', 8, 75); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(1, buffer9); |
| } catch {} |
| let buffer155 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let commandEncoder156 = device0.createCommandEncoder(); |
| let texture173 = device0.createTexture({ |
| size: [780, 48, 1], |
| mipLevelCount: 3, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder8.drawIndexed(2, 0, 0, 89_869_243); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer53, 'uint16', 2, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(5, buffer104, 0, 387); |
| } catch {} |
| try { |
| buffer95.unmap(); |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 1, resource: externalTexture13}, {binding: 3, resource: textureView17}], |
| }); |
| let texture174 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture175 = device0.createTexture({ |
| size: {width: 32, height: 48, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView189 = texture61.createView({}); |
| try { |
| computePassEncoder6.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer110, 36); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(6, buffer152, 8, 2); |
| } catch {} |
| try { |
| renderBundleEncoder12.insertDebugMarker('\u{1fa4a}'); |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let texture176 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture177 = device0.createTexture({ |
| size: [780, 48, 1], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture30 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(72, 0, 59_612_385); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer55, 1_504); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup36, [0]); |
| } catch {} |
| try { |
| commandEncoder150.clearBuffer(buffer58); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 80, new Float32Array(2470).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.517)), 214, 4); |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer75}}, |
| {binding: 557, resource: externalTexture7}, |
| {binding: 176, resource: {buffer: buffer107}}, |
| ], |
| }); |
| let texture178 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'astc-8x8-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder7.drawIndexed(24, 0, 1, 435_406_195); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer151, 2_904); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup36, [0]); |
| } catch {} |
| document.body.append(img1); |
| let autogeneratedBindGroupLayout14 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder158 = device0.createCommandEncoder(); |
| let texture179 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture180 = device0.createTexture({ |
| size: [780, 480, 1], |
| format: 'astc-6x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView190 = texture138.createView({}); |
| let sampler26 = device0.createSampler({addressModeU: 'mirror-repeat'}); |
| try { |
| renderPassEncoder7.draw(385, 0, 1_518_322_128); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(17, 0, 11, -1_876_588_228); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(5, buffer62); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup57); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer1, 'uint16', 68, 23); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 156, new Float32Array(3065).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.274)), 384, 440); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| let texture181 = device0.createTexture({ |
| size: [1560, 96, 1], |
| mipLevelCount: 1, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture182 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView191 = texture90.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup14, [0]); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(11, 0, 300_966_473); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(6, 0, 2, 1_258_959_994); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer89, 40); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(6, buffer92); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder87.copyBufferToTexture({ |
| /* bytesInLastRow: 1060 widthInBlocks: 265 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1836 */ |
| offset: 1836, |
| bytesPerRow: 4864, |
| rowsPerImage: 254, |
| buffer: buffer118, |
| }, { |
| texture: texture181, |
| mipLevel: 0, |
| origin: {x: 12, y: 19, z: 0}, |
| aspect: 'all', |
| }, {width: 265, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder79.copyTextureToTexture({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 12}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture156, |
| mipLevel: 2, |
| origin: {x: 10, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let imageData25 = new ImageData(16, 24); |
| let autogeneratedBindGroupLayout15 = pipeline30.getBindGroupLayout(0); |
| let texture183 = device0.createTexture({ |
| size: [390, 240, 1], |
| format: 'astc-10x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup65); |
| } catch {} |
| try { |
| renderPassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer120, 'uint16', 10, 13); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline13); |
| } catch {} |
| let commandBuffer4 = commandEncoder105.finish(); |
| let texture184 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture185 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView192 = texture15.createView({ |
| label: '\u5ff8\u2057\ua242\u0980\uddd7\u{1f87e}\ue699\u7500\u37a5', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| }); |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer9, 'uint32', 0, 28); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(4, buffer132); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 10, resource: {buffer: buffer154}}]}); |
| let buffer156 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder159 = device0.createCommandEncoder(); |
| let texture186 = device0.createTexture({ |
| size: {width: 16, height: 24, depthOrArrayLayers: 5}, |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView193 = texture64.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer52, 'uint32', 4, 2); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| } catch {} |
| let texture187 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup81, new Uint32Array(357), 24, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer156, 0, new Uint16Array(29572).map((_, i) => i + 9), 8554, 4); |
| } catch {} |
| let buffer157 = device0.createBuffer({size: 101, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let texture188 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'astc-5x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder17.setStencilReference(2505); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer43, 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer154, 'uint32', 32, 23); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer129, 0, new Float32Array(13657).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.319)), 1329, 0); |
| } catch {} |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| let commandBuffer5 = commandEncoder45.finish({}); |
| let texture189 = device0.createTexture({ |
| size: [390, 240, 1], |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView194 = texture159.createView({}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer74, 'uint16', 10, 11); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline26); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let promise21 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x3be68f99}, |
| fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint'}]}, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex6', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 920, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x4', offset: 8, shaderLocation: 13}, |
| {format: 'uint32x2', offset: 224, shaderLocation: 12}, |
| {format: 'unorm8x2', offset: 96, shaderLocation: 9}, |
| {format: 'float32x4', offset: 4, shaderLocation: 4}, |
| {format: 'sint16x2', offset: 160, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'back', unclippedDepth: true}, |
| }); |
| document.body.append(canvas3); |
| let commandEncoder162 = device0.createCommandEncoder({}); |
| let texture190 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView195 = texture5.createView({}); |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder163 = device0.createCommandEncoder(); |
| let textureView196 = texture49.createView({dimension: '2d-array'}); |
| let textureView197 = texture69.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup14, new Uint32Array(3460), 544, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.end(); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer108, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder49.clearBuffer(buffer76); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 3, resource: textureView3}, |
| {binding: 6, resource: {buffer: buffer136}}, |
| {binding: 43, resource: {buffer: buffer106}}, |
| {binding: 58, resource: {buffer: buffer107}}, |
| ], |
| }); |
| let commandEncoder164 = device0.createCommandEncoder({}); |
| let texture191 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 4, |
| format: 'astc-5x4-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer107, 'uint32', 124, 478); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup81, new Uint32Array(1640), 154, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let texture192 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'astc-10x8-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture193 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer38, 'uint16', 0, 4); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline20); |
| } catch {} |
| try { |
| commandEncoder127.copyTextureToBuffer({ |
| texture: texture185, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 7252 */ |
| offset: 7252, |
| bytesPerRow: 0, |
| rowsPerImage: 1738, |
| buffer: buffer91, |
| }, {width: 0, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| commandEncoder143.resolveQuerySet(querySet0, 92, 0, buffer80, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 7, y: 13 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 204, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 59, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture194 = device0.createTexture({ |
| size: {width: 8, height: 600, depthOrArrayLayers: 1}, |
| format: 'astc-8x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView198 = texture107.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 3}); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup58, [0]); |
| } catch {} |
| let texture195 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture196 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 1, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer145, 'uint16', 2, 81); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup37, new Uint32Array(1887), 21, 0); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: []}); |
| let buffer158 = device0.createBuffer({size: 236, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder165 = device0.createCommandEncoder({}); |
| let texture197 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.30, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer137, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer55, 'uint16', 3_990, 911); |
| } catch {} |
| let pipeline37 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule7, |
| constants: {override20: 1, override18: 1}, |
| buffers: [ |
| { |
| arrayStride: 204, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x3', offset: 4, shaderLocation: 11}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 6}, |
| {format: 'float32x3', offset: 36, shaderLocation: 8}, |
| {format: 'float16x2', offset: 28, shaderLocation: 13}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 4}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 104, shaderLocation: 5}, |
| {format: 'float32x3', offset: 16, shaderLocation: 14}, |
| {format: 'float32x4', offset: 12, shaderLocation: 12}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 10}, |
| {format: 'uint32', offset: 16, shaderLocation: 7}, |
| {format: 'uint32', offset: 8, shaderLocation: 9}, |
| {format: 'uint32', offset: 4, shaderLocation: 3}, |
| ], |
| }, |
| {arrayStride: 428, attributes: [{format: 'snorm16x4', offset: 68, shaderLocation: 0}]}, |
| ], |
| }, |
| primitive: {cullMode: 'back', unclippedDepth: true}, |
| }); |
| let autogeneratedBindGroupLayout16 = pipeline22.getBindGroupLayout(0); |
| let commandBuffer6 = commandEncoder7.finish(); |
| let texture198 = device0.createTexture({ |
| size: [390, 240, 1], |
| mipLevelCount: 2, |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture199 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView199 = texture184.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline31); |
| } catch {} |
| let arrayBuffer10 = buffer143.getMappedRange(8, 0); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 20, new DataView(new Uint8Array(3790).map((_, i) => i).buffer), 80, 16); |
| } catch {} |
| await gc(); |
| let bindGroup87 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 81, resource: externalTexture10}, |
| {binding: 2, resource: textureView100}, |
| {binding: 3, resource: textureView197}, |
| {binding: 251, resource: {buffer: buffer5}}, |
| {binding: 86, resource: {buffer: buffer116}}, |
| {binding: 5, resource: {buffer: buffer37, size: 528}}, |
| {binding: 166, resource: textureView138}, |
| {binding: 141, resource: {buffer: buffer80}}, |
| {binding: 15, resource: {buffer: buffer116}}, |
| {binding: 1, resource: externalTexture26}, |
| {binding: 11, resource: textureView26}, |
| {binding: 6, resource: textureView3}, |
| {binding: 12, resource: textureView186}, |
| {binding: 148, resource: {buffer: buffer82}}, |
| {binding: 220, resource: {buffer: buffer21, size: 884}}, |
| {binding: 4, resource: {buffer: buffer110}}, |
| {binding: 152, resource: textureView87}, |
| {binding: 125, resource: textureView151}, |
| {binding: 106, resource: {buffer: buffer107, offset: 256, size: 2136}}, |
| {binding: 0, resource: {buffer: buffer116}}, |
| ], |
| }); |
| let buffer159 = device0.createBuffer({size: 124, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture200 = device0.createTexture({ |
| size: [16, 24, 55], |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture31 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder10.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer107, 132); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup83); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer55, 'uint16', 38, 333); |
| } catch {} |
| try { |
| renderBundleEncoder26.insertDebugMarker('\u{1fa0e}'); |
| } catch {} |
| let pipeline38 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x289e374}, |
| fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 28, |
| attributes: [ |
| {format: 'sint8x4', offset: 0, shaderLocation: 7}, |
| {format: 'unorm8x4', offset: 4, shaderLocation: 11}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 4}, |
| {format: 'snorm16x4', offset: 8, shaderLocation: 6}, |
| {format: 'unorm16x4', offset: 4, shaderLocation: 2}, |
| {format: 'float32x3', offset: 0, shaderLocation: 8}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 13}, |
| {format: 'float32x3', offset: 0, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 4, shaderLocation: 3}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 9}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 15}, |
| {format: 'sint16x2', offset: 4, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 6, shaderLocation: 12}, |
| {format: 'uint32', offset: 16, shaderLocation: 1}, |
| {format: 'sint32x3', offset: 16, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw'}, |
| }); |
| let commandEncoder166 = device0.createCommandEncoder(); |
| let texture201 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView200 = texture55.createView({dimension: '2d-array', baseMipLevel: 2, mipLevelCount: 1}); |
| try { |
| computePassEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup74, new Uint32Array(5798), 853, 0); |
| } catch {} |
| await gc(); |
| let bindGroup88 = device0.createBindGroup({ |
| label: '\u6e96\u5aa4\ua7e2', |
| layout: autogeneratedBindGroupLayout15, |
| entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer158}}], |
| }); |
| let texture202 = device0.createTexture({ |
| size: [1560, 96, 1], |
| mipLevelCount: 4, |
| format: 'astc-6x6-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView201 = texture178.createView({mipLevelCount: 1}); |
| try { |
| commandEncoder95.copyTextureToTexture({ |
| texture: texture89, |
| mipLevel: 0, |
| origin: {x: 1, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture12, |
| mipLevel: 2, |
| origin: {x: 3, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 116, new Uint32Array(10942).map((_, i) => i * 7), 1959, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame11, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 169, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData26 = new ImageData(12, 120); |
| try { |
| globalThis.someLabel = commandEncoder71.label; |
| } catch {} |
| let texture203 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder22.setPipeline(pipeline27); |
| } catch {} |
| try { |
| buffer75.unmap(); |
| } catch {} |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'bt2020', transfer: 'bt1361ExtendedColourGamut'} }); |
| let texture204 = device0.createTexture({ |
| size: {width: 16, height: 24, depthOrArrayLayers: 25}, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture205 = device0.createTexture({ |
| size: {width: 780}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder22 = commandEncoder145.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView130, |
| clearValue: { r: -953.6, g: -849.1, b: -286.5, a: 878.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer112, 'uint32', 36, 64); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer112, 'uint16', 2, 15); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| document.body.prepend(img0); |
| let texture206 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 1}, |
| format: 'astc-4x4-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView202 = texture185.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup86, new Uint32Array(208), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline12); |
| } catch {} |
| try { |
| commandEncoder136.copyTextureToBuffer({ |
| texture: texture165, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 720 */ |
| offset: 720, |
| buffer: buffer91, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let texture207 = device0.createTexture({ |
| size: [390, 240, 1], |
| mipLevelCount: 2, |
| format: 'astc-10x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup53, new Uint32Array(2196), 684, 1); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer107, 'uint32', 160, 652); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1310 */ |
| offset: 1310, |
| rowsPerImage: 724, |
| buffer: buffer11, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder143.clearBuffer(buffer140); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer154, 28, new Float32Array(11713).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.534)), 1166, 12); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame26, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 14, y: 13, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet3 = device0.createQuerySet({type: 'timestamp', count: 275}); |
| let textureView203 = texture161.createView({}); |
| let textureView204 = texture1.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup64, new Uint32Array(1771), 82, 2); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 12, new Float16Array(13329).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.807)), 101, 24); |
| } catch {} |
| let pipeline39 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule4, constants: {}, targets: [{format: 'rg8sint', writeMask: GPUColorWrite.RED}]}, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex1', |
| buffers: [ |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'uint8x2', offset: 2, shaderLocation: 1}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 11}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 4}, |
| {format: 'sint32', offset: 0, shaderLocation: 13}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 0}, |
| ], |
| }, |
| { |
| arrayStride: 64, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32x3', offset: 8, shaderLocation: 3}, |
| {format: 'float32', offset: 4, shaderLocation: 2}, |
| {format: 'float16x2', offset: 16, shaderLocation: 9}, |
| {format: 'float32x4', offset: 12, shaderLocation: 14}, |
| {format: 'uint32', offset: 12, shaderLocation: 15}, |
| {format: 'float16x2', offset: 12, shaderLocation: 6}, |
| {format: 'sint8x4', offset: 12, shaderLocation: 7}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 12}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let bindGroup89 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 3, resource: textureView0}, {binding: 1, resource: externalTexture5}], |
| }); |
| let texture208 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture209 = device0.createTexture({ |
| size: [780], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView205 = texture207.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup84, new Uint32Array(1948), 305, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer52, 'uint16', 14, 3); |
| } catch {} |
| let texture210 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'astc-10x10-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder5.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline38); |
| } catch {} |
| let buffer160 = device0.createBuffer({size: 192, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let texture211 = device0.createTexture({ |
| size: [32, 48, 1], |
| mipLevelCount: 3, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup89); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToTexture({ |
| texture: texture55, |
| mipLevel: 6, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 28, y: 95, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| renderBundleEncoder3.label = '\u01dd\u8325'; |
| } catch {} |
| let texture212 = device0.createTexture({ |
| size: [2, 2, 14], |
| dimension: '2d', |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup66, new Uint32Array(1615), 270, 1); |
| } catch {} |
| try { |
| renderPassEncoder16.setStencilReference(395); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(1, buffer8); |
| } catch {} |
| try { |
| buffer43.unmap(); |
| } catch {} |
| let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'gamma28curve'} }); |
| let textureView206 = texture212.createView({ |
| label: '\u0cfa\u0c95\ub60f\u0675\uc981\u03a0\u91fc', |
| dimension: 'cube-array', |
| baseMipLevel: 0, |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| let externalTexture32 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder23.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup3, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1596), 294, 1); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer112, 'uint16', 14, 8); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(5, buffer8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 11, y: 30, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(122).fill(204), /* required buffer size: 122 */ |
| {offset: 122}, {width: 101, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let img5 = await imageWithData(3, 19, '#10101010', '#20202020'); |
| let texture213 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 76}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler28 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 72.50}); |
| try { |
| renderPassEncoder12.setScissorRect(193, 7, 290, 2); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(0, buffer96, 0); |
| } catch {} |
| try { |
| buffer38.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame24, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 122, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(22); }; |
| } catch {} |
| let buffer161 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture214 = device0.createTexture({ |
| size: [195, 120, 17], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture33 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup77, new Uint32Array(3860), 26, 0); |
| } catch {} |
| try { |
| commandEncoder10.copyTextureToTexture({ |
| texture: texture164, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 98, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 4, new Float32Array(8821).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.534)), 791, 0); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder169 = device0.createCommandEncoder({}); |
| let textureView207 = texture213.createView({format: 'rgba16sint'}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder2.pushDebugGroup('\u745e'); |
| } catch {} |
| let buffer162 = device0.createBuffer({size: 384, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder170 = device0.createCommandEncoder({}); |
| let textureView208 = texture214.createView({baseMipLevel: 0}); |
| let textureView209 = texture21.createView({baseMipLevel: 0, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer1, 'uint16', 46, 81); |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 2, resource: textureView100}, |
| {binding: 141, resource: {buffer: buffer136}}, |
| {binding: 251, resource: {buffer: buffer45}}, |
| {binding: 4, resource: {buffer: buffer116}}, |
| {binding: 166, resource: textureView88}, |
| {binding: 15, resource: {buffer: buffer116}}, |
| {binding: 1, resource: externalTexture19}, |
| {binding: 152, resource: textureView90}, |
| {binding: 0, resource: {buffer: buffer107, offset: 0, size: 940}}, |
| {binding: 148, resource: {buffer: buffer35}}, |
| {binding: 3, resource: textureView154}, |
| {binding: 220, resource: {buffer: buffer120}}, |
| {binding: 125, resource: textureView29}, |
| {binding: 81, resource: externalTexture22}, |
| {binding: 86, resource: {buffer: buffer37}}, |
| {binding: 11, resource: textureView38}, |
| {binding: 6, resource: textureView3}, |
| {binding: 106, resource: {buffer: buffer107}}, |
| {binding: 5, resource: {buffer: buffer116}}, |
| {binding: 12, resource: textureView186}, |
| ], |
| }); |
| let commandEncoder171 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer108, 'uint32', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(1, buffer71, 0, 3); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 14, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 28, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let buffer163 = device0.createBuffer({size: 228, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder172 = device0.createCommandEncoder(); |
| let commandBuffer7 = commandEncoder163.finish(); |
| let texture215 = device0.createTexture({ |
| size: [780, 480, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup88); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer136, 'uint16', 60, 4); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| renderBundleEncoder0.insertDebugMarker('\ubc44'); |
| } catch {} |
| await gc(); |
| let commandEncoder173 = device0.createCommandEncoder({}); |
| let textureView210 = texture212.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer93, 'uint32', 32, 25); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline26); |
| } catch {} |
| try { |
| await promise22; |
| } catch {} |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder38.insertDebugMarker('\u06bc'); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise23; |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer158}}, |
| {binding: 6, resource: {buffer: buffer110}}, |
| {binding: 58, resource: {buffer: buffer107}}, |
| {binding: 3, resource: textureView0}, |
| ], |
| }); |
| let texture216 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder15.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer90, 'uint16', 6, 234); |
| } catch {} |
| let autogeneratedBindGroupLayout17 = pipeline3.getBindGroupLayout(0); |
| let texture217 = device0.createTexture({size: [8], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup49, new Uint32Array(25), 11, 0); |
| } catch {} |
| let pipeline40 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule6, |
| constants: {}, |
| targets: [{ |
| format: 'r16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule9, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 12, |
| stepMode: 'instance', |
| attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 3}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let buffer164 = device0.createBuffer({size: 148, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView211 = texture182.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup56, new Uint32Array(120), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline20); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture9.label = '\u{1fb7a}\u11d9\u014c'; |
| } catch {} |
| let shaderModule12 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| @group(0) @binding(58) var<storage, read_write> buffer167: array<array<array<array<array<array<array<f16, 1>, 3>, 1>, 16>, 1>, 1>, 6>; |
| |
| var<private> vp11: array<array<i32, 1>, 27> = array<array<i32, 1>, 27>(array(i32(306384506)), array<i32, 1>(), array(i32(425600027)), array<i32, 1>(), array(i32(189241111)), array(i32(613836695)), array<i32, 1>(i32(243277045)), array(i32(259924265)), array(i32(300242831)), array(i32(31819780)), array<i32, 1>(), array<i32, 1>(i32(1022644442)), array(i32(543973360)), array<i32, 1>(i32(672953362)), array(i32(448591984)), array(i32(202704976)), array(i32(551320201)), array<i32, 1>(i32(-202918266)), array<i32, 1>(), array(i32(-1842400409)), array(i32(129822122)), array<i32, 1>(), array<i32, 1>(), array<i32, 1>(), array(i32(17800868)), array<i32, 1>(), array<i32, 1>(i32(89215586))); |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T3 { |
| f0: array<T2>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct FragmentInput27 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| @group(2) @binding(1) var et15: texture_external; |
| |
| struct FragmentInput28 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| var<private> vp12 = modf(vec4f(0.2640e3, -0.1765, 0.2056, 0.1388)); |
| |
| @group(1) @binding(3) var<storage, read_write> buffer168: array<array<array<u32, 1648>, 1>>; |
| |
| struct T0 { |
| @size(104) f0: vec2i, |
| } |
| |
| struct T2 { |
| @align(8) @size(8) f0: atomic<u32>, |
| } |
| |
| struct ComputeInput14 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| @group(1) @binding(115) var st14: texture_storage_2d_array<r32sint, write>; |
| |
| struct T1 { |
| @align(16) f0: array<u32>, |
| } |
| |
| struct T4 { |
| f0: array<f32, 26>, |
| } |
| |
| @group(0) @binding(43) var<uniform> buffer166: array<vec4i, 6>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(2) @binding(138) var st15: texture_storage_2d<r32uint, read_write>; |
| |
| @group(1) @binding(10) var<storage, read> buffer170: array<array<array<f16, 5>, 6>>; |
| |
| struct ComputeInput13 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| var<private> vp10: array<f32, 1> = array(f32(0.02945e-6)); |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp9: vec4u = vec4u(103201143, 1420125475, 461396148, 282816634); |
| |
| /* used global variables: buffer166 */ |
| @vertex @must_use |
| fn vertex14(@builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| for (var jj87=0u; jj87<3; jj87++) { vp10[jj87] *= bitcast<vec4f>(buffer166[5])[3]; } |
| out += vec4f(bitcast<f32>(vp11[26][unconst_u32(136875352)])); |
| let ptr68: ptr<private, vec4u> = &vp9; |
| return out; |
| _ = buffer166; |
| } |
| |
| /* used global variables: buffer168, et15 */ |
| @fragment |
| fn fragment11(@builtin(position) position: vec4f, a1: FragmentInput27, a2: FragmentInput28) -> @location(200) @interpolate(linear, sample) i32 { |
| var out: i32; |
| vp10[unconst_u32(99905190)] = bitcast<f32>(textureDimensions(et15).x); |
| let ptr69: ptr<storage, u32, read_write> = &(*&buffer168)[arrayLength(&(*&buffer168))][0][1647]; |
| vp12.whole = unpack4x8unorm((*&buffer168)[arrayLength(&(*&buffer168))][0][1647]); |
| let vf142: mat4x3f = (unconst_f32(0.8598e-1) * mat4x3f(unconst_f32(0.2608), unconst_f32(0.07464e31), unconst_f32(0.07892), unconst_f32(0.1136e9), unconst_f32(0.00560e33), unconst_f32(0.1388), unconst_f32(0.03617), unconst_f32(0.3922), unconst_f32(0.4709), unconst_f32(0.1029e11), unconst_f32(0.5366), unconst_f32(0.01415))); |
| return out; |
| _ = et15; |
| _ = buffer168; |
| } |
| |
| /* used global variables: buffer167, buffer168, st14, st15 */ |
| @compute @workgroup_size(3, 1, 1) |
| fn compute10() { |
| let ptr70: ptr<storage, f16, read_write> = &(*&buffer167)[unconst_u32(1139005338)][unconst_u32(387260768)][0][unconst_u32(53966115)][0][2][unconst_u32(100578843)]; |
| var vf143: vec4h = tanh(vec4h(unconst_f16(17862.8), unconst_f16(19441.9), unconst_f16(31034.3), unconst_f16(10930.1))); |
| switch i32((*&buffer167)[unconst_u32(110991078)][0][unconst_u32(1318037802)][unconst_u32(348845946)][unconst_u32(461547965)][2][unconst_u32(1746344140)]) { |
| default: { |
| let ptr71: ptr<storage, array<array<array<array<f16, 1>, 3>, 1>, 16>, read_write> = &buffer167[unconst_u32(101464342)][unconst_u32(220293226)][0]; |
| textureBarrier(); |
| buffer167[5][unconst_u32(189585770)][unconst_u32(97322354)][unconst_u32(1234143498)][unconst_u32(20633679)][unconst_u32(547721150)][unconst_u32(426389953)] = buffer167[5][unconst_u32(567369462)][0][15][0][2][0]; |
| let ptr72: ptr<storage, f16, read_write> = &buffer167[unconst_u32(463683007)][0][0][unconst_u32(57115250)][0][2][unconst_u32(541391999)]; |
| textureStore(st14, vec2i(unconst_i32(475989772), unconst_i32(84672903)), unconst_i32(141780332), vec4i(vec4i(unconst_i32(-646246507), unconst_i32(824903189), unconst_i32(22659480), unconst_i32(-115862765)))); |
| return; |
| _ = st14; |
| _ = buffer167; |
| } |
| case 529017198 { |
| for (var jj43=0u; jj43<29; jj43++) { for (var jj56=0u; jj56<3; jj56++) { vp11[jj43][jj56] &= i32((*&buffer167)[5][0][0][unconst_u32(431480068)][unconst_u32(154786779)][unconst_u32(445277139)][0]); } } |
| _ = buffer167; |
| } |
| } |
| var vf144: vec4h = sqrt(vec4h(unconst_f16(1456.6), unconst_f16(-21743.8), unconst_f16(829.4), unconst_f16(5695.5))); |
| vf143 -= vec4h(buffer167[unconst_u32(265893568)][0][unconst_u32(1061344706)][unconst_u32(25673393)][0][2][0]); |
| textureStore(st15, vec2i(unconst_i32(143188840), unconst_i32(638011858)), vec4u(vec4u(unconst_u32(1489363220), unconst_u32(225786917), unconst_u32(266926613), unconst_u32(215008414)))); |
| vp12 = modf(unpack4x8unorm((*&buffer168)[unconst_u32(4566049)][0][1647])); |
| _ = st15; |
| _ = buffer167; |
| _ = buffer168; |
| _ = st14; |
| } |
| |
| /* used global variables: buffer167, buffer168, buffer170, st14, st15 */ |
| @compute @workgroup_size(5, 1, 1) |
| fn compute11(@builtin(local_invocation_id) local_invocation_id: vec3u, a1: ComputeInput13, a2: ComputeInput14) { |
| let ptr73: ptr<storage, array<f16, 1>, read_write> = &buffer167[5][unconst_u32(974541747)][unconst_u32(2072427982)][unconst_u32(3089607778)][0][2]; |
| let ptr74: ptr<storage, array<u32, 1648>, read_write> = &(*&buffer168)[arrayLength(&(*&buffer168))][0]; |
| textureStore(st15, vec2i(unconst_i32(-1292983303), unconst_i32(162344957)), vec4u(vec4u(unconst_u32(982815440), unconst_u32(599425360), unconst_u32(271619146), unconst_u32(25972289)))); |
| let ptr75: ptr<storage, f16, read> = &buffer170[arrayLength(&buffer170)][5][4]; |
| let ptr76: ptr<storage, array<f16, 5>, read> = &buffer170[arrayLength(&buffer170)][5]; |
| let ptr77: ptr<storage, array<f16, 1>, read_write> = &buffer167[5][0][unconst_u32(661736042)][unconst_u32(922773692)][0][unconst_u32(2151693175)]; |
| let ptr78: ptr<storage, f16, read_write> = &buffer167[unconst_u32(790962177)][0][0][15][unconst_u32(94312991)][2][unconst_u32(1236082833)]; |
| textureStore(st14, vec2i(unconst_i32(53434941), unconst_i32(251567993)), unconst_i32(94508328), vec4i(vec4i(unconst_i32(-99097030), unconst_i32(414866547), unconst_i32(678789207), unconst_i32(-747292677)))); |
| let ptr79: ptr<storage, f16, read> = &(*&buffer170)[u32((*&buffer167)[unconst_u32(853333726)][0][0][unconst_u32(123202568)][0][2][0])][5][unconst_u32(1245073883)]; |
| vp9 |= unpack4xU8(u32(vp11[unconst_u32(468324213)][unconst_u32(1078100549)])); |
| _ = st15; |
| _ = buffer168; |
| _ = buffer170; |
| _ = buffer167; |
| _ = st14; |
| }`, |
| }); |
| let bindGroup92 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [{binding: 1, resource: externalTexture19}, {binding: 3, resource: textureView0}], |
| }); |
| let commandEncoder175 = device0.createCommandEncoder(); |
| let texture218 = device0.createTexture({ |
| size: {width: 390}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup4, new Uint32Array(2483), 37, 1); |
| } catch {} |
| try { |
| commandEncoder165.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2500 */ |
| offset: 2500, |
| bytesPerRow: 13312, |
| buffer: buffer118, |
| }, { |
| texture: texture155, |
| mipLevel: 1, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder2.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let buffer172 = device0.createBuffer({ |
| size: 28, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer160, 0, 34); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup31, new Uint32Array(998), 111, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame17, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 345, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} }); |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| let textureView212 = texture209.createView({}); |
| let renderPassEncoder23 = commandEncoder43.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView146, |
| depthSlice: 7, |
| clearValue: { r: 619.4, g: -187.4, b: 835.9, a: 318.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup79, new Uint32Array(2121), 906, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer65, 'uint16', 4, 2); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer100, 'uint32', 8, 20); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture122, |
| mipLevel: 0, |
| origin: {x: 17, y: 12, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(31); }; |
| } catch {} |
| document.body.prepend(img0); |
| let buffer173 = device0.createBuffer({size: 328, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let commandEncoder178 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup89, new Uint32Array(2557), 187, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(3, 50, 0, -1_831_499_130, 182_710_488); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(4, buffer139, 0); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| let imageData27 = new ImageData(16, 124); |
| let texture219 = device0.createTexture({ |
| size: {width: 390}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer45, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer54, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| buffer139.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer156, 4, new Float32Array(3123).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.283)), 18, 0); |
| } catch {} |
| await gc(); |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| let textureView213 = texture206.createView({}); |
| try { |
| renderPassEncoder13.draw(202, 297_335_434, 322_410_367, 1_630_723_502); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(4, 18, 0, 208_321_095, 113_693_811); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(3, buffer143, 0); |
| } catch {} |
| let canvas6 = document.createElement('canvas'); |
| let buffer174 = device0.createBuffer({ |
| label: '\uc5d3\u065a\u{1f806}\u6238\u8ad8\u04af\u3567', |
| size: 164, |
| usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder180 = device0.createCommandEncoder(); |
| let renderPassEncoder24 = commandEncoder28.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView130, |
| clearValue: { r: 478.9, g: 224.5, b: 934.2, a: -574.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| renderPassEncoder13.drawIndirect(buffer77, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer128, 'uint16', 0, 9); |
| } catch {} |
| try { |
| commandEncoder168.insertDebugMarker('\u9374'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 0, new Uint32Array(3085).map((_, i) => i * 10), 151, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer175 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC}); |
| let texture220 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView214 = texture54.createView({aspect: 'all'}); |
| try { |
| computePassEncoder10.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(12, 1_264_832_625, 1_016_939_961, 780_235_615); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(3, buffer172); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| document.body.append(canvas4); |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup32, new Uint32Array(3643), 361, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline13); |
| } catch {} |
| try { |
| await buffer140.mapAsync(GPUMapMode.READ, 0, 12); |
| } catch {} |
| let pipeline41 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x4f62fc9}, |
| fragment: { |
| module: shaderModule6, |
| constants: {}, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 28, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 0, shaderLocation: 14}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 2}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 6}, |
| {format: 'float32', offset: 12, shaderLocation: 7}, |
| {format: 'sint32', offset: 0, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 18, shaderLocation: 11}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 12}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 3}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 1}, |
| {format: 'sint32', offset: 4, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 13}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 8}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 0}, |
| {format: 'sint32x2', offset: 4, shaderLocation: 5}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let gpuCanvasContext12 = canvas6.getContext('webgpu'); |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(49); }; |
| } catch {} |
| let autogeneratedBindGroupLayout18 = pipeline22.getBindGroupLayout(0); |
| let buffer176 = device0.createBuffer({ |
| size: 4, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.draw(42, 151_995_937, 3_145_665_174, 18_944_870); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup64, new Uint32Array(2073), 612, 2); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(0, buffer154, 0); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let autogeneratedBindGroupLayout19 = pipeline36.getBindGroupLayout(0); |
| let bindGroup93 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 3, resource: textureView17}, |
| {binding: 6, resource: {buffer: buffer5}}, |
| {binding: 43, resource: {buffer: buffer80}}, |
| {binding: 58, resource: {buffer: buffer116}}, |
| ], |
| }); |
| let textureView215 = texture169.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline22); |
| } catch {} |
| try { |
| commandEncoder101.insertDebugMarker('\u0d8d'); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| let imageData28 = new ImageData(4, 56); |
| let commandEncoder182 = device0.createCommandEncoder({label: '\uee11\u094c'}); |
| let texture221 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView216 = texture127.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder13.draw(166, 520_473_871, 15_162_527, 132_701_701); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(1, buffer160, 0, 75); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(2, bindGroup42); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(64); }; |
| } catch {} |
| let img6 = await imageWithData(10, 10, '#10101010', '#20202020'); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 6.573, |
| compare: 'less', |
| maxAnisotropy: 1, |
| }); |
| let externalTexture34 = device0.importExternalTexture({source: videoFrame23}); |
| try { |
| renderPassEncoder13.draw(215, 1_326_796_488, 6_728_321, 221_747_716); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(3, 529, 0, 377_696_254, 1_447_959_403); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(0, buffer43, 4, 0); |
| } catch {} |
| try { |
| buffer43.unmap(); |
| } catch {} |
| let pipeline42 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x20ba5e63}, |
| fragment: {module: shaderModule1, targets: [{format: 'rg8sint'}]}, |
| vertex: { |
| module: shaderModule1, |
| constants: {override0: 1}, |
| buffers: [ |
| { |
| arrayStride: 64, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32', offset: 8, shaderLocation: 11}, |
| {format: 'float32x4', offset: 4, shaderLocation: 2}, |
| {format: 'float32x4', offset: 8, shaderLocation: 8}, |
| {format: 'snorm8x2', offset: 10, shaderLocation: 12}, |
| {format: 'uint32', offset: 0, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 6}, |
| {format: 'uint16x4', offset: 8, shaderLocation: 1}, |
| {format: 'snorm8x4', offset: 12, shaderLocation: 5}, |
| {format: 'sint32x2', offset: 8, shaderLocation: 10}, |
| {format: 'uint32x2', offset: 28, shaderLocation: 15}, |
| {format: 'sint32', offset: 8, shaderLocation: 0}, |
| {format: 'float16x2', offset: 8, shaderLocation: 14}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 13}, |
| {format: 'float32x3', offset: 0, shaderLocation: 9}, |
| {format: 'sint16x4', offset: 12, shaderLocation: 7}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-list'}, |
| }); |
| document.body.append(canvas3); |
| let bindGroup94 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 557, resource: externalTexture19}, |
| {binding: 176, resource: {buffer: buffer107}}, |
| {binding: 0, resource: {buffer: buffer70}}, |
| ], |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup74, new Uint32Array(1981), 446, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup9, new Uint32Array(110), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(3, 139, 0, 19_626_077, 512_054_424); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'}); |
| } catch {} |
| let buffer177 = device0.createBuffer({size: 8, usage: GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup78, new Uint32Array(294), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.beginOcclusionQuery(794); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(40, 1_785_616_377, 307_516_417, 715_166_655); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(3, 160, 2, 6_560_020, 459_869_301); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer136, 4); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer136, 'uint16', 4, 13); |
| } catch {} |
| try { |
| buffer118.unmap(); |
| } catch {} |
| try { |
| commandEncoder112.insertDebugMarker('\uaef3'); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let buffer178 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let texture222 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 231}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder13.draw(51, 737_964_412, 3_057_501_638, 316_249_803); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer55, 9_540); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(1, buffer5, 88); |
| } catch {} |
| try { |
| renderPassEncoder12.insertDebugMarker('\u5d5f'); |
| } catch {} |
| let bindGroup95 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let externalTexture35 = device0.importExternalTexture({source: videoFrame12}); |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup48, new Uint32Array(137), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer136, 'uint32', 24, 19); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer112, 'uint32', 160, 9); |
| } catch {} |
| try { |
| adapter0.label = '\u{1f8e0}\u0cb9\u{1ff89}\u36a6\u7d77\u0352\ua260\u{1ffc5}\u{1f77a}'; |
| } catch {} |
| let buffer179 = device0.createBuffer({ |
| size: 336, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView217 = texture213.createView({format: 'rgba16sint'}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup88, new Uint32Array(164), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup3, new Uint32Array(303), 41, 1); |
| } catch {} |
| try { |
| renderPassEncoder19.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer102, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer68, 0, 109); |
| } catch {} |
| try { |
| commandEncoder86.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1656 */ |
| offset: 1656, |
| bytesPerRow: 4864, |
| buffer: buffer11, |
| }, { |
| texture: texture181, |
| mipLevel: 0, |
| origin: {x: 203, y: 14, z: 0}, |
| aspect: 'all', |
| }, {width: 16, height: 28, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img6); |
| let bindGroup96 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 15, resource: {buffer: buffer111, size: 320}}, |
| {binding: 220, resource: {buffer: buffer157, size: 4}}, |
| {binding: 81, resource: externalTexture30}, |
| {binding: 141, resource: {buffer: buffer20, offset: 0}}, |
| {binding: 86, resource: {buffer: buffer37}}, |
| {binding: 0, resource: {buffer: buffer107, offset: 512}}, |
| {binding: 166, resource: textureView88}, |
| {binding: 2, resource: textureView82}, |
| {binding: 125, resource: textureView153}, |
| {binding: 3, resource: textureView134}, |
| {binding: 4, resource: {buffer: buffer120, size: 89}}, |
| {binding: 251, resource: {buffer: buffer37}}, |
| {binding: 6, resource: textureView3}, |
| {binding: 5, resource: {buffer: buffer116}}, |
| {binding: 148, resource: {buffer: buffer66}}, |
| {binding: 1, resource: externalTexture33}, |
| {binding: 12, resource: textureView205}, |
| {binding: 11, resource: textureView151}, |
| {binding: 106, resource: {buffer: buffer116, offset: 0}}, |
| {binding: 152, resource: textureView90}, |
| ], |
| }); |
| let buffer180 = device0.createBuffer({size: 48, usage: GPUBufferUsage.UNIFORM}); |
| let textureView218 = texture105.createView({}); |
| let textureView219 = texture198.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder8.setPipeline(pipeline34); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(90, 737_719_947, 314_347_918, 418_819_613); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer33, 68); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 24, new DataView(new ArrayBuffer(43616)), 1844, 8); |
| } catch {} |
| let buffer181 = device0.createBuffer({size: 104, usage: GPUBufferUsage.INDIRECT}); |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(15, 331_089_451, 298_347_044, 96_276_681); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(5, 194, 0, 605_727_864, 322_688_601); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer59, 20); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img6, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 123, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture223 = device0.createTexture({size: [4, 6, 1], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView220 = texture195.createView({aspect: 'all', baseMipLevel: 0}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup62); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder184 = device0.createCommandEncoder(); |
| let texture224 = device0.createTexture({ |
| size: [195, 120, 270], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup81, new Uint32Array(2253), 923, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(5, 26, 2, 310_384_736, 920_991_901); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer102, 48); |
| } catch {} |
| try { |
| gpuCanvasContext11.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(62); }; |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({layout: autogeneratedBindGroupLayout10, entries: [{binding: 10, resource: {buffer: buffer5}}]}); |
| let commandEncoder185 = device0.createCommandEncoder({}); |
| let texture225 = device0.createTexture({ |
| label: '\u{1fcd8}\ue003', |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture226 = device0.createTexture({ |
| size: [8, 12, 1], |
| mipLevelCount: 1, |
| sampleCount: 4, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer45, 16); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer65, 'uint32', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline42); |
| } catch {} |
| try { |
| commandEncoder178.copyTextureToBuffer({ |
| texture: texture23, |
| mipLevel: 2, |
| origin: {x: 12, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 852 */ |
| offset: 852, |
| bytesPerRow: 1280, |
| rowsPerImage: 7, |
| buffer: buffer91, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let textureView221 = texture225.createView({}); |
| let texture227 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 1}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder13.drawIndirect(buffer178, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline38); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 8, new DataView(new ArrayBuffer(1032)), 123, 52); |
| } catch {} |
| let texture228 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView222 = texture149.createView({aspect: 'all', arrayLayerCount: 3}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup47, []); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 45, 1, -1_089_266_969, 898_492_150); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer55, 2_696); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u0622'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 97, height: 60, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 3, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| let textureView223 = texture228.createView({}); |
| let texture229 = device0.createTexture({ |
| size: [195, 12, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let texture230 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView224 = texture129.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer59, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer151, 804); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(0, buffer9, 32); |
| } catch {} |
| let pipeline43 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, entryPoint: 'compute7', constants: {}}}); |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let textureView225 = texture209.createView({}); |
| try { |
| renderPassEncoder21.setBindGroup(2, bindGroup39, new Uint32Array(279), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(130, 571_737_458, 1_466_094_024, 2_081_533_416); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 188, 0, -1_635_125_725, 598_336_777); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer4, 20); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer35, 16); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(5, buffer136, 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup14, [0]); |
| } catch {} |
| let promise25 = shaderModule1.getCompilationInfo(); |
| let pipeline44 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let imageData29 = new ImageData(12, 24); |
| let commandEncoder188 = device0.createCommandEncoder({}); |
| let textureView226 = texture122.createView({mipLevelCount: 1}); |
| let sampler30 = device0.createSampler({ |
| label: '\u0de1\u9999\u5b3d\u{1ff1d}\ua53f', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| compare: 'always', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup12, new Uint32Array(253), 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup95, new Uint32Array(2138), 536, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(31, 1_830_054_584, 1_858_748_354, 80_228_639); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer77, 4); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer74, 'uint32', 44, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer112, 'uint32', 72, 15); |
| } catch {} |
| try { |
| commandEncoder76.resolveQuerySet(querySet0, 25, 0, buffer65, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout20 = pipeline42.getBindGroupLayout(0); |
| let texture231 = device0.createTexture({size: [4], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let externalTexture36 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup92, new Uint32Array(505), 126, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 340, 1, 120_078_627, 236_160_155); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer110, 16); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup76); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup2, new Uint32Array(1363), 154, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer176, 'uint32', 0, 0); |
| } catch {} |
| try { |
| buffer64.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(14, 191_639_915, 412_040_676, 351_573_546); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 305, 0, 15_663_123, 1_223_975_775); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer45, 0); |
| } catch {} |
| try { |
| commandEncoder86.copyBufferToBuffer(buffer60, 84, buffer11, 488, 56); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 12, new Uint16Array(13572).map((_, i) => i + 7), 1776, 532); |
| } catch {} |
| try { |
| device0.queue.label = '\u{1f643}\ub4d5\u46d1\ua07c\ufff9'; |
| } catch {} |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 145, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| renderPassEncoder13.drawIndexed(2, 199, 0, 237_993_180, 195_093_477); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer39, 44); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup49); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer9, 'uint32', 32, 0); |
| } catch {} |
| let offscreenCanvas7 = new OffscreenCanvas(14, 151); |
| let commandEncoder189 = device0.createCommandEncoder({}); |
| let texture232 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 2}, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture233 = gpuCanvasContext6.getCurrentTexture(); |
| let textureView227 = texture167.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder13.draw(23, 629_600_755, 614_046_536, 1_258_368_836); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup94, new Uint32Array(2499), 423, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer154, 'uint16', 4, 37); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(6, buffer96, 0); |
| } catch {} |
| try { |
| buffer112.unmap(); |
| } catch {} |
| try { |
| commandEncoder60.clearBuffer(buffer120); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer66, 60, new Float64Array(2408).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/2404)), 203, 8); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup95, new Uint32Array(1650), 330, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer39, 56); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer151, 692); |
| } catch {} |
| try { |
| buffer54.unmap(); |
| } catch {} |
| try { |
| commandEncoder164.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1102 */ |
| offset: 1102, |
| bytesPerRow: 38656, |
| buffer: buffer118, |
| }, { |
| texture: texture102, |
| mipLevel: 1, |
| origin: {x: 43, y: 4, z: 2}, |
| aspect: 'all', |
| }, {width: 1, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder190 = device0.createCommandEncoder({}); |
| let texture234 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder13.drawIndirect(buffer172, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer129, 0, new Float16Array(13607).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.097)), 3057, 0); |
| } catch {} |
| let commandEncoder191 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup8, [0]); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(3, 101, 0, 843_611_294, 418_986_860); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer117, 8); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(0, buffer19); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder173.copyBufferToBuffer(buffer141, 32, buffer75, 120, 36); |
| } catch {} |
| try { |
| renderBundleEncoder12.insertDebugMarker('\ua00b'); |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer77, 152); |
| } catch {} |
| try { |
| computePassEncoder0.insertDebugMarker('\u8009'); |
| } catch {} |
| let imageData30 = new ImageData(28, 32); |
| try { |
| renderPassEncoder13.draw(98, 870_406_090, 76_114_635, 53_069_537); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer103, 20); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(0, buffer154, 8, 2); |
| } catch {} |
| try { |
| commandEncoder144.copyBufferToBuffer(buffer8, 4, buffer138, 8, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| let texture235 = device0.createTexture({ |
| size: [195, 120, 1], |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView228 = texture140.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup42, new Uint32Array(441), 76, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(224, 569_076_760, 465_611_757, 1_608_468_681); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(3, 313, 0, 415_085_255, 613_355_830); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer144, 8); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer128, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline38); |
| } catch {} |
| try { |
| commandEncoder178.copyBufferToBuffer(buffer179, 16, buffer58, 20, 36); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture182, |
| mipLevel: 3, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(46).fill(30), /* required buffer size: 46 */ |
| {offset: 46, bytesPerRow: 19}, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext12.unconfigure(); |
| } catch {} |
| let bindGroup98 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer80}}, |
| {binding: 3, resource: textureView3}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| {binding: 6, resource: {buffer: buffer105, size: 24}}, |
| ], |
| }); |
| let texture236 = gpuCanvasContext2.getCurrentTexture(); |
| try { |
| renderPassEncoder13.draw(22, 169_496_123, 185_032_177, 85_673_160); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer55, 1_128); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 97, height: 60, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 7, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext13 = offscreenCanvas7.getContext('webgpu'); |
| try { |
| renderPassEncoder13.drawIndirect(buffer172, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup21, new Uint32Array(561), 64, 1); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer137, 'uint32', 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(7, buffer82, 0, 18); |
| } catch {} |
| let buffer182 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let texture237 = device0.createTexture({size: [8], dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer93, 4); |
| } catch {} |
| try { |
| commandEncoder161.copyTextureToTexture({ |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 8, y: 7, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer163, 36, new Float32Array(12762).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6002)), 885, 8); |
| } catch {} |
| let bindGroup99 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 141, resource: {buffer: buffer35}}, |
| {binding: 3, resource: textureView80}, |
| {binding: 4, resource: {buffer: buffer66}}, |
| {binding: 5, resource: {buffer: buffer73, size: 16}}, |
| {binding: 15, resource: {buffer: buffer5}}, |
| {binding: 6, resource: textureView17}, |
| {binding: 12, resource: textureView32}, |
| {binding: 2, resource: textureView97}, |
| {binding: 125, resource: textureView151}, |
| {binding: 106, resource: {buffer: buffer116}}, |
| {binding: 166, resource: textureView138}, |
| {binding: 81, resource: externalTexture20}, |
| {binding: 251, resource: {buffer: buffer34}}, |
| {binding: 0, resource: {buffer: buffer21, size: 972}}, |
| {binding: 11, resource: textureView151}, |
| {binding: 1, resource: externalTexture12}, |
| {binding: 220, resource: {buffer: buffer110}}, |
| {binding: 152, resource: textureView87}, |
| {binding: 86, resource: {buffer: buffer21, size: 1836}}, |
| {binding: 148, resource: {buffer: buffer108}}, |
| ], |
| }); |
| let texture238 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.drawIndexed(3, 44, 1, -1_943_170_070, 558_763_703); |
| } catch {} |
| let commandEncoder195 = device0.createCommandEncoder({}); |
| let texture239 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 798}, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView229 = texture152.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder13.draw(1_000, 474_687_180, 2_167_415_024, 632_690_041); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer112, 8); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer69, 'uint32', 140, 6); |
| } catch {} |
| try { |
| buffer89.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder22.insertDebugMarker('\u7709'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 2, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 148, y: 7, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup100 = device0.createBindGroup({layout: autogeneratedBindGroupLayout19, entries: []}); |
| try { |
| renderPassEncoder13.drawIndexed(2, 316, 1, -2_092_909_914, 85_898_536); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(1, bindGroup42, new Uint32Array(1884), 205, 0); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder92.copyBufferToTexture({ |
| /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1244 */ |
| offset: 1244, |
| bytesPerRow: 14848, |
| buffer: buffer11, |
| }, { |
| texture: texture182, |
| mipLevel: 1, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 9, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture7.label; |
| } catch {} |
| let commandEncoder196 = device0.createCommandEncoder({}); |
| let externalTexture37 = device0.importExternalTexture({source: videoFrame16}); |
| try { |
| renderPassEncoder13.draw(132, 65_500_393, 1_208_469_028, 41_450_675); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(6, buffer104, 0, 90); |
| } catch {} |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let textureView230 = texture154.createView({}); |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer100, 'uint32', 64, 11); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer55, 'uint16', 24, 7_635); |
| } catch {} |
| try { |
| commandEncoder44.copyTextureToTexture({ |
| texture: texture114, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup101 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []}); |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let texture240 = device0.createTexture({ |
| size: {width: 16}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture38 = device0.importExternalTexture({source: videoFrame27, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder13.drawIndexed(2, 126, 0, 431_177_790, 665_197_780); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer65, 'uint16', 2, 4); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer131, 'uint16', 62, 5); |
| } catch {} |
| try { |
| commandEncoder129.clearBuffer(buffer154); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 0, new Uint32Array(15775).map((_, i) => i * 9), 1641, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(193); }; |
| } catch {} |
| let buffer183 = device0.createBuffer({size: 136, usage: GPUBufferUsage.INDEX}); |
| let computePassEncoder26 = commandEncoder161.beginComputePass({timestampWrites: {querySet: querySet0, beginningOfPassWriteIndex: 349, endOfPassWriteIndex: 166}}); |
| try { |
| computePassEncoder26.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(124, 152_478_059, 422_591_375, 909_758_509); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 12, 0, 112_296_876, 702_435_695); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer4, 32); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer178, 20); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(6, buffer106, 0, 33); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 60, new DataView(new ArrayBuffer(3042)), 351, 4); |
| } catch {} |
| document.body.append(img4); |
| try { |
| renderPassEncoder13.drawIndexed(2, 19, 1, 25_422_864, 424_799_178); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer102, 24); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup68); |
| } catch {} |
| let pipeline45 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule11, constants: {}}}); |
| let texture241 = gpuCanvasContext5.getCurrentTexture(); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup100, new Uint32Array(666), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(371, 817_906_635, 811_469_991, 18_446_659); |
| } catch {} |
| let bindGroup102 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 348, resource: {buffer: buffer35}}, |
| {binding: 47, resource: textureView100}, |
| {binding: 241, resource: {buffer: buffer111, size: 416}}, |
| {binding: 711, resource: sampler18}, |
| {binding: 7, resource: {buffer: buffer34, offset: 0}}, |
| {binding: 3, resource: sampler29}, |
| {binding: 556, resource: textureView24}, |
| {binding: 290, resource: {buffer: buffer127, offset: 0, size: 12}}, |
| {binding: 10, resource: textureView26}, |
| {binding: 6, resource: textureView62}, |
| ], |
| }); |
| let commandEncoder199 = device0.createCommandEncoder({label: '\u{1f778}\u{1f750}\u{1f93f}\u0593\ue7dc\u002d\u{1fd4a}\ud86e\u{1f6e7}'}); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(255, 919_899_051, 975_337_982, 143_754_165); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(0, buffer176, 0, 2); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let arrayBuffer11 = buffer140.getMappedRange(0, 4); |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer82, 0, new DataView(new Uint8Array(12173).map((_, i) => i).buffer), 236, 0); |
| } catch {} |
| let texture242 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| renderPassEncoder13.draw(7, 392_271_142, 1_006_625_995, 239_105_988); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer3, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer111, 20, 59); |
| } catch {} |
| let arrayBuffer12 = buffer140.getMappedRange(8, 0); |
| try { |
| commandEncoder94.copyTextureToBuffer({ |
| texture: texture197, |
| mipLevel: 0, |
| origin: {x: 62, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 304 widthInBlocks: 76 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 944 */ |
| offset: 944, |
| bytesPerRow: 40960, |
| rowsPerImage: 35, |
| buffer: buffer11, |
| }, {width: 76, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView231 = texture72.createView({}); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup97, new Uint32Array(7836), 65, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.beginOcclusionQuery(481); |
| } catch {} |
| try { |
| renderPassEncoder9.setBlendConstant({ r: -741.6, g: -757.0, b: 541.3, a: -778.6, }); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer107, 408); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer43, 12); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer9, 'uint16', 12, 10); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToBuffer(buffer155, 0, buffer154, 16, 0); |
| } catch {} |
| let buffer184 = device0.createBuffer({label: '\u5da4\u0c5c\u0e79\u2aa8\u5c8d\u0936\u6131\ue53e', size: 320, usage: GPUBufferUsage.COPY_DST}); |
| let texture243 = device0.createTexture({ |
| size: {width: 390}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView232 = texture136.createView({dimension: '2d-array', format: 'rg8sint'}); |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer181, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer106, 'uint16', 30, 5); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup51, new Uint32Array(1871), 3, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 62, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture244 = device0.createTexture({ |
| size: [390, 24, 1], |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView233 = texture210.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder13.drawIndexed(7, 324, 0, 6_288_010, 1_180_038_497); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer59, 8); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer33, 36); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas6, |
| origin: { x: 43, y: 18 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 95, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 42, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline46 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment1', |
| constants: {}, |
| targets: [{format: 'r16sint', writeMask: 0}], |
| }, |
| vertex: { |
| module: shaderModule7, |
| constants: {override18: 1}, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 8}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 15}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 12}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 6}, |
| {format: 'uint32', offset: 0, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 0}, |
| {format: 'float16x2', offset: 0, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'snorm16x2', offset: 212, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 12, shaderLocation: 3}, |
| {format: 'snorm8x2', offset: 616, shaderLocation: 14}, |
| {format: 'uint16x2', offset: 48, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true}, |
| }); |
| try { |
| globalThis.someLabel = texture243.label; |
| } catch {} |
| let externalTexture39 = device0.importExternalTexture({source: videoFrame12}); |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup89, []); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(151, 433_097_386, 1_169_194_166, 107_320_338); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer45, 0); |
| } catch {} |
| await gc(); |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 33, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 40, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 45, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 84, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 117, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 148, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 201, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 210, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 211, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 219, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 255, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 264, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 269, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 284, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 386, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture245 = device0.createTexture({ |
| size: [2, 2, 14], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView234 = texture200.createView({dimension: '2d', baseArrayLayer: 9}); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: false}); |
| try { |
| computePassEncoder4.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(499, 1_573_883_190, 20_520_345, 333_481_313); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer104, 64); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder102.copyTextureToTexture({ |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 413, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 294, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 234, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder15.insertDebugMarker('\u62f2'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 56, new DataView(new ArrayBuffer(35048)), 2258, 4); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| document.body.prepend(img0); |
| let textureView235 = texture90.createView({}); |
| try { |
| renderPassEncoder20.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(14, 33_281_357, 474_709_205, 34_535_074); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer102, 12); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer154, 'uint32', 32, 41); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup1, new Uint32Array(1573), 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(1, buffer128, 0); |
| } catch {} |
| try { |
| commandEncoder49.copyBufferToTexture({ |
| /* bytesInLastRow: 256 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 2768 */ |
| offset: 2768, |
| bytesPerRow: 1024, |
| buffer: buffer118, |
| }, { |
| texture: texture210, |
| mipLevel: 0, |
| origin: {x: 80, y: 190, z: 0}, |
| aspect: 'all', |
| }, {width: 160, height: 60, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder141.resolveQuerySet(querySet1, 54, 1, buffer164, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer82, 48, new BigInt64Array(22556).map((_, i) => BigInt(i - 9)), 294, 0); |
| } catch {} |
| let promise26 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder200 = device0.createCommandEncoder(); |
| let computePassEncoder27 = commandEncoder200.beginComputePass(); |
| try { |
| computePassEncoder27.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup74, new Uint32Array(918), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(182, 626_803_479, 707_221_462, 95_034_335); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer112, 52); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline40); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 8, new DataView(new Uint8Array(7215).map((_, i) => i).buffer), 300, 4); |
| } catch {} |
| let buffer185 = device0.createBuffer({size: 11752, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder201 = device0.createCommandEncoder({}); |
| let externalTexture40 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder9.drawIndexed(2, 0, 2, 282_271_899); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer102, 28); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer137, 'uint16', 2, 3); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(6, buffer143, 12, 4); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup37); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer128, 'uint16', 0, 2); |
| } catch {} |
| try { |
| commandEncoder97.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1792 */ |
| offset: 1792, |
| bytesPerRow: 10496, |
| buffer: buffer118, |
| }, { |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 132, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer137, 4, new Float32Array(6174).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.563)), 1121, 0); |
| } catch {} |
| let imageData31 = new ImageData(72, 4); |
| let commandEncoder202 = device0.createCommandEncoder({}); |
| let texture246 = device0.createTexture({ |
| size: [2, 2, 14], |
| mipLevelCount: 1, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView236 = texture170.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer136, 20); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline16); |
| } catch {} |
| let autogeneratedBindGroupLayout21 = pipeline13.getBindGroupLayout(0); |
| let sampler31 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 68.59, |
| compare: 'greater', |
| maxAnisotropy: 5, |
| }); |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(86, 311_367_275, 621_183_293, 588_432_733); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 61, 0, 101_291_593, 1_012_709_740); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer62, 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer107, 'uint32', 408, 59); |
| } catch {} |
| let canvas7 = document.createElement('canvas'); |
| let imageBitmap1 = await createImageBitmap(videoFrame23); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup17, new Uint32Array(153), 16, 1); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup89); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(42, 1_151_863_789, 963_543_556, 188_067_451); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fe32}\u0e96\u{1ffdf}\u1e52\ubb5e\u42df\ua50f\u6230\u055b'; |
| } catch {} |
| let bindGroup103 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 176, resource: {buffer: buffer21, size: 2428}}, |
| {binding: 557, resource: externalTexture9}, |
| {binding: 0, resource: {buffer: buffer35, offset: 0}}, |
| ], |
| }); |
| let commandEncoder203 = device0.createCommandEncoder({}); |
| let textureView237 = texture239.createView({label: '\uf455\u631e\u6a77\uba74\u4a8c\ufac2\u90c7\ud154\ue5da\u1023', baseArrayLayer: 0}); |
| let texture247 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView238 = texture204.createView({aspect: 'depth-only', baseArrayLayer: 12, arrayLayerCount: 2}); |
| let renderPassEncoder25 = commandEncoder104.beginRenderPass({ |
| colorAttachments: [{view: textureView126, loadOp: 'load', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 12, endOfPassWriteIndex: 172}, |
| maxDrawCount: 23606588, |
| }); |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer133, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer93, 104); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(5, buffer59, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(3, buffer176, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture134, |
| mipLevel: 4, |
| origin: {x: 27, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(64).fill(224), /* required buffer size: 64 */ |
| {offset: 64}, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext10.unconfigure(); |
| } catch {} |
| let bindGroup104 = device0.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 1, resource: externalTexture19}]}); |
| let commandEncoder204 = device0.createCommandEncoder(); |
| let textureView239 = texture145.createView({dimension: '2d'}); |
| let renderPassEncoder26 = commandEncoder53.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView111, |
| depthSlice: 30, |
| clearValue: { r: 478.6, g: 87.22, b: -913.5, a: -825.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| timestampWrites: {querySet: querySet0}, |
| }); |
| try { |
| renderPassEncoder13.drawIndexed(2, 4, 2, 420_641_647, 1_048_739_006); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer73, 4); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer107, 'uint16', 196, 199); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer128, 'uint16', 0, 4); |
| } catch {} |
| offscreenCanvas5.height = 407; |
| let bindGroup105 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 3, resource: textureView17}, |
| {binding: 6, resource: {buffer: buffer158}}, |
| {binding: 58, resource: {buffer: buffer21, size: 1648}}, |
| {binding: 43, resource: {buffer: buffer64}}, |
| ], |
| }); |
| let commandEncoder205 = device0.createCommandEncoder({}); |
| let textureView240 = texture73.createView({}); |
| let renderPassEncoder27 = commandEncoder195.beginRenderPass({ |
| label: '\u44ef\u70f0\u041a\u2485\u04d8\ucfab\u2d74\u{1f607}', |
| colorAttachments: [{ |
| view: textureView126, |
| clearValue: { r: 10.13, g: 461.8, b: -68.31, a: -437.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| timestampWrites: {querySet: querySet3, endOfPassWriteIndex: 97}, |
| maxDrawCount: 115845954, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup10, [0]); |
| } catch {} |
| try { |
| renderPassEncoder26.beginOcclusionQuery(820); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer103, 16); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup32, new Uint32Array(5299), 268, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder174.insertDebugMarker('\u063b'); |
| } catch {} |
| let textureView241 = texture46.createView({label: '\u001f\u4008\u3b8d\u01b7\u3325\u048a\u1ab6\u{1f742}\u{1fa8d}\u7240'}); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup23, new Uint32Array(267), 129, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup104, new Uint32Array(838), 165, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.draw(52, 766_426_167, 417_179_854, 277_200_487); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexed(2, 427, 1, -2_063_035_585, 485_759_214); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndexedIndirect(buffer89, 12); |
| } catch {} |
| try { |
| renderPassEncoder13.drawIndirect(buffer110, 16); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline46); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup4, [0]); |
| } catch {} |
| let commandEncoder206 = device0.createCommandEncoder({}); |
| let texture248 = device0.createTexture({ |
| size: [32, 48, 8], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup92); |
| } catch {} |
| try { |
| renderPassEncoder13.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(6, buffer185, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup92); |
| } catch {} |
| try { |
| gpuCanvasContext11.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture215, |
| mipLevel: 0, |
| origin: {x: 162, y: 47, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(228).fill(135), /* required buffer size: 228 */ |
| {offset: 228, bytesPerRow: 96}, {width: 44, height: 102, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte170m', transfer: 'log'} }); |
| let bindGroup106 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer103}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 58, resource: {buffer: buffer21, size: 600}}, |
| {binding: 43, resource: {buffer: buffer174}}, |
| ], |
| }); |
| let buffer186 = device0.createBuffer({size: 426, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandBuffer8 = commandEncoder32.finish(); |
| let texture249 = device0.createTexture({ |
| size: [195, 12, 1], |
| sampleCount: 4, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture250 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture251 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView242 = texture71.createView({baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 3}); |
| let externalTexture41 = device0.importExternalTexture({source: videoFrame10}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer145, 'uint32', 24, 18); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer90, 'uint32', 260, 21); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer179, 32, new Uint32Array(4480).map((_, i) => i * 5), 3032, 8); |
| } catch {} |
| try { |
| await promise26; |
| } catch {} |
| let commandEncoder207 = device0.createCommandEncoder({}); |
| let commandBuffer9 = commandEncoder39.finish(); |
| let texture252 = device0.createTexture({ |
| size: {width: 195, height: 120, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView243 = texture26.createView({}); |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup82); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer80, 0, new Float32Array(1857).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4047)), 1147, 0); |
| } catch {} |
| let bindGroup107 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup99, [256, 0]); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer139, 0, 23); |
| } catch {} |
| try { |
| computePassEncoder13.insertDebugMarker('\u{1fac7}'); |
| } catch {} |
| let promise27 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise27; |
| } catch {} |
| let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'jedecP22Phosphors', transfer: 'iec61966-2-1'} }); |
| let commandEncoder208 = device0.createCommandEncoder({}); |
| let textureView244 = texture249.createView({baseArrayLayer: 0}); |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup38); |
| } catch {} |
| let texture253 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup4, new Uint32Array(527), 103, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer100, 'uint32', 52, 32); |
| } catch {} |
| let autogeneratedBindGroupLayout22 = pipeline30.getBindGroupLayout(0); |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup82); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline39); |
| } catch {} |
| try { |
| renderBundleEncoder25.insertDebugMarker('\u05bf'); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 4, new Float32Array(2328).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.333)), 41, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(92); }; |
| } catch {} |
| let sampler32 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', maxAnisotropy: 1}); |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup41); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer137, 12, new Uint32Array(823).map((_, i) => i * 5), 57, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 1, y: 7 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 17, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 23, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer187 = device0.createBuffer({size: 1088, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup43, new Uint32Array(546), 78, 0); |
| } catch {} |
| try { |
| commandEncoder139.resolveQuerySet(querySet1, 160, 8, buffer70, 0); |
| } catch {} |
| let commandEncoder209 = device0.createCommandEncoder({}); |
| let textureView245 = texture228.createView({}); |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup102, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer131, 'uint16', 190, 102); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(0, buffer139, 0, 18); |
| } catch {} |
| let imageData32 = new ImageData(4, 80); |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }}, |
| {binding: 32, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 48, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 184, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 365, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }, |
| ], |
| }); |
| let commandEncoder210 = device0.createCommandEncoder({}); |
| let texture254 = device0.createTexture({ |
| label: '\u094a\u{1fbbc}\u15db\u{1f92d}\u11d7\udd22\u4623\u{1fc4e}\u0d26\u33ad', |
| size: {width: 195}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup19, [0]); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup103, new Uint32Array(3472), 387, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer144, 'uint16', 38, 4); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(2, buffer118, 148); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture209, |
| mipLevel: 0, |
| origin: {x: 170, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(72).fill(129), /* required buffer size: 72 */ |
| {offset: 72}, {width: 45, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise28 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise28; |
| } catch {} |
| await gc(); |
| let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} }); |
| let textureView246 = texture75.createView({dimension: '2d', baseArrayLayer: 27, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup95); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer107, 'uint32', 4, 1_288); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(0, bindGroup16, []); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture255 = device0.createTexture({ |
| size: [780, 48, 1], |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture42 = device0.importExternalTexture({source: videoFrame25}); |
| try { |
| renderBundleEncoder20.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder204.copyBufferToBuffer(buffer117, 0, buffer7, 0, 8); |
| } catch {} |
| let bindGroup108 = device0.createBindGroup({layout: autogeneratedBindGroupLayout21, entries: [{binding: 1, resource: externalTexture38}]}); |
| let texture256 = device0.createTexture({ |
| size: {width: 97}, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup85, new Uint32Array(318), 74, 1); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup104, new Uint32Array(659), 101, 0); |
| } catch {} |
| let pipeline47 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule9, constants: {}}}); |
| let autogeneratedBindGroupLayout23 = pipeline5.getBindGroupLayout(0); |
| let bindGroup109 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout22, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer157, size: 28}}, |
| {binding: 58, resource: {buffer: buffer21, offset: 1280, size: 1008}}, |
| ], |
| }); |
| let textureView247 = texture198.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder22.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline38); |
| } catch {} |
| let gpuCanvasContext14 = canvas7.getContext('webgpu'); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 7, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 14, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 33, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 39, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 212, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup110 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer116}}, |
| {binding: 220, resource: {buffer: buffer20, offset: 0}}, |
| {binding: 125, resource: textureView241}, |
| {binding: 81, resource: externalTexture33}, |
| {binding: 251, resource: {buffer: buffer174}}, |
| {binding: 152, resource: textureView87}, |
| {binding: 11, resource: textureView239}, |
| {binding: 2, resource: textureView82}, |
| {binding: 1, resource: externalTexture27}, |
| {binding: 86, resource: {buffer: buffer37, size: 916}}, |
| {binding: 166, resource: textureView138}, |
| {binding: 5, resource: {buffer: buffer111, size: 364}}, |
| {binding: 15, resource: {buffer: buffer21, size: 416}}, |
| {binding: 4, resource: {buffer: buffer106}}, |
| {binding: 141, resource: {buffer: buffer174}}, |
| {binding: 106, resource: {buffer: buffer116}}, |
| {binding: 12, resource: textureView186}, |
| {binding: 3, resource: textureView134}, |
| {binding: 148, resource: {buffer: buffer146}}, |
| {binding: 6, resource: textureView3}, |
| ], |
| }); |
| let buffer188 = device0.createBuffer({size: 466, usage: GPUBufferUsage.INDEX}); |
| let texture257 = device0.createTexture({ |
| size: [16, 24, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView248 = texture202.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 2}); |
| try { |
| commandEncoder194.copyTextureToBuffer({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1804 */ |
| offset: 1804, |
| bytesPerRow: 54016, |
| rowsPerImage: 263, |
| buffer: buffer91, |
| }, {width: 1, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder197.pushDebugGroup('\u1e14'); |
| } catch {} |
| try { |
| commandEncoder197.popDebugGroup(); |
| } catch {} |
| try { |
| renderPassEncoder20.label = '\u0a76\u3c3a\u6def\u14d5'; |
| } catch {} |
| let buffer189 = device0.createBuffer({size: 28, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder211 = device0.createCommandEncoder({}); |
| let textureView249 = texture105.createView({format: 'rg8sint', arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer145, 'uint16', 28, 12); |
| } catch {} |
| offscreenCanvas1.width = 98; |
| let textureView250 = texture255.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup40, new Uint32Array(3550), 787, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.beginOcclusionQuery(159); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer1, 'uint32', 0, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 76, new Float64Array(1276).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/1276)), 157, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 162, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 371, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let buffer190 = device0.createBuffer({size: 196, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder212 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup0, new Uint32Array(145), 138, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline27); |
| } catch {} |
| try { |
| buffer183.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let buffer191 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let texture258 = device0.createTexture({ |
| size: {width: 97}, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView251 = texture127.createView({}); |
| try { |
| renderPassEncoder26.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline42); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(0, buffer62, 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(5, buffer19, 0, 97); |
| } catch {} |
| let canvas8 = document.createElement('canvas'); |
| let buffer192 = device0.createBuffer({size: 31, usage: GPUBufferUsage.COPY_DST}); |
| let texture259 = device0.createTexture({ |
| size: {width: 16, height: 24, depthOrArrayLayers: 166}, |
| mipLevelCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup102, new Uint32Array(348), 7, 1); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer106, 'uint16', 8, 22); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer55, 'uint16', 346, 2_535); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline42); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(48); }; |
| } catch {} |
| let autogeneratedBindGroupLayout24 = pipeline39.getBindGroupLayout(0); |
| let commandEncoder213 = device0.createCommandEncoder({}); |
| let textureView252 = texture66.createView({}); |
| let computePassEncoder28 = commandEncoder167.beginComputePass(); |
| try { |
| computePassEncoder28.setPipeline(pipeline34); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup21, [0]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 2, y: 21 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer193 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let externalTexture43 = device0.importExternalTexture({source: videoFrame22, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder27.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(16); }; |
| } catch {} |
| let videoFrame34 = new VideoFrame(videoFrame22, {timestamp: 0}); |
| try { |
| computePassEncoder27.setBindGroup(3, bindGroup101, new Uint32Array(618), 35, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(4, buffer107, 0, 45); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer55, 'uint16', 1_264, 3_589); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer154, 20, new Float16Array(25342).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.9348)), 59, 4); |
| } catch {} |
| let buffer194 = device0.createBuffer({size: 320, usage: GPUBufferUsage.INDIRECT}); |
| let texture260 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 218}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup56); |
| } catch {} |
| try { |
| buffer160.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 68, new DataView(new ArrayBuffer(20836)), 826, 0); |
| } catch {} |
| try { |
| computePassEncoder9.insertDebugMarker('\u6758'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer192, 0, new Float16Array(4761).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.4251)), 3057, 4); |
| } catch {} |
| let videoFrame35 = new VideoFrame(img4, {timestamp: 0}); |
| let bindGroup111 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer80}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 6, resource: {buffer: buffer136}}, |
| {binding: 58, resource: {buffer: buffer107}}, |
| ], |
| }); |
| let sampler33 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.49, |
| maxAnisotropy: 14, |
| }); |
| try { |
| buffer39.unmap(); |
| } catch {} |
| let textureView253 = texture71.createView({dimension: '2d', baseArrayLayer: 1}); |
| let renderPassEncoder28 = commandEncoder90.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView145, |
| depthSlice: 3, |
| clearValue: { r: 10.07, g: -342.9, b: -315.1, a: -152.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(2, bindGroup38, []); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(5, buffer77, 12, 84); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(5, buffer118, 0, 1_477); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer153, 0, new Uint16Array(10586).map((_, i) => i + 1), 2148, 0); |
| } catch {} |
| let bindGroup112 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 81, resource: externalTexture17}, |
| {binding: 166, resource: textureView88}, |
| {binding: 3, resource: textureView154}, |
| {binding: 148, resource: {buffer: buffer179}}, |
| {binding: 125, resource: textureView250}, |
| {binding: 106, resource: {buffer: buffer107}}, |
| {binding: 141, resource: {buffer: buffer5}}, |
| {binding: 1, resource: externalTexture8}, |
| {binding: 5, resource: {buffer: buffer75, offset: 0}}, |
| {binding: 12, resource: textureView186}, |
| {binding: 6, resource: textureView0}, |
| {binding: 15, resource: {buffer: buffer5, offset: 0}}, |
| {binding: 0, resource: {buffer: buffer37}}, |
| {binding: 11, resource: textureView151}, |
| {binding: 2, resource: textureView97}, |
| {binding: 251, resource: {buffer: buffer35, size: 20}}, |
| {binding: 86, resource: {buffer: buffer37}}, |
| {binding: 4, resource: {buffer: buffer51, offset: 0}}, |
| {binding: 152, resource: textureView90}, |
| {binding: 220, resource: {buffer: buffer60}}, |
| ], |
| }); |
| let buffer195 = device0.createBuffer({size: 398, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder214 = device0.createCommandEncoder({}); |
| let texture261 = device0.createTexture({size: [1560, 96, 1], mipLevelCount: 4, format: 'r16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let externalTexture44 = device0.importExternalTexture({source: videoFrame20}); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup39, new Uint32Array(2298), 786, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup104); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer131, 'uint16', 184, 56); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline16); |
| } catch {} |
| try { |
| commandEncoder146.copyTextureToBuffer({ |
| texture: texture213, |
| mipLevel: 0, |
| origin: {x: 21, y: 9, z: 3}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 128 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2808 */ |
| offset: 2808, |
| bytesPerRow: 56832, |
| rowsPerImage: 269, |
| buffer: buffer91, |
| }, {width: 16, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise29 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise29; |
| } catch {} |
| let commandEncoder215 = device0.createCommandEncoder({}); |
| let textureView254 = texture210.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup29, []); |
| } catch {} |
| try { |
| renderPassEncoder25.insertDebugMarker('\uf503'); |
| } catch {} |
| let imageData33 = new ImageData(4, 60); |
| let textureView255 = texture82.createView({format: 'rgba16uint'}); |
| let texture262 = device0.createTexture({ |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture45 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup11, [0]); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 32, new Float32Array(10847).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.7711)), 6, 0); |
| } catch {} |
| let canvas9 = document.createElement('canvas'); |
| let commandEncoder216 = device0.createCommandEncoder({}); |
| try { |
| buffer132.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 97, height: 60, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 29, y: 5 }, |
| flipY: false, |
| }, { |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 18, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout25 = pipeline41.getBindGroupLayout(1); |
| let texture263 = gpuCanvasContext3.getCurrentTexture(); |
| let externalTexture46 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup53, new Uint32Array(7569), 1_526, 1); |
| } catch {} |
| try { |
| commandEncoder203.resolveQuerySet(querySet1, 217, 0, buffer178, 0); |
| } catch {} |
| let renderPassEncoder29 = commandEncoder164.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView145, |
| depthSlice: 6, |
| clearValue: { r: -821.7, g: 314.7, b: -64.70, a: 462.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture47 = device0.importExternalTexture({source: videoFrame11}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup25, [0]); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup89); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 113_544_639, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer62, 0, 2); |
| } catch {} |
| try { |
| buffer53.unmap(); |
| } catch {} |
| try { |
| commandEncoder146.resolveQuerySet(querySet2, 79, 0, buffer108, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 64, new DataView(new ArrayBuffer(5111)), 54, 0); |
| } catch {} |
| let videoFrame36 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(10, 0, 384_884_883); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 548_523_735); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer184, 28, new Float32Array(11107).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.201)), 2488, 44); |
| } catch {} |
| let externalTexture48 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup7, new Uint32Array(933), 224, 1); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(283, 0, 203_766_668); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 18_843_804); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer117, 8); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer110, 56); |
| } catch {} |
| try { |
| commandEncoder177.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 810 */ |
| offset: 810, |
| bytesPerRow: 11520, |
| buffer: buffer118, |
| }, { |
| texture: texture205, |
| mipLevel: 0, |
| origin: {x: 207, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer101, 12, new Uint32Array(127).map((_, i) => i * 6), 1, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout26 = pipeline17.getBindGroupLayout(0); |
| let bindGroup113 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let texture264 = device0.createTexture({ |
| label: '\u03fd\u09bf\u1c60\u54a2\u039a\u{1fdaa}\u4a39\u{1f696}\u03b7\uf53d', |
| size: {width: 390, height: 24, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup43, new Uint32Array(717), 166, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup89); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(268, 0, 370_189_414); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer22, 16); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer109, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer108, 'uint16', 6, 1); |
| } catch {} |
| try { |
| buffer152.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder21.insertDebugMarker('\u{1f94c}'); |
| } catch {} |
| document.body.prepend(canvas4); |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 279_826_889); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer39, 48); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(6, buffer5, 0, 15); |
| } catch {} |
| try { |
| commandEncoder189.resolveQuerySet(querySet1, 111, 0, buffer50, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| await gc(); |
| let texture265 = device0.createTexture({ |
| size: [780, 480, 1], |
| sampleCount: 4, |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder24.beginOcclusionQuery(183); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(0, buffer143); |
| } catch {} |
| try { |
| commandEncoder188.copyTextureToBuffer({ |
| texture: texture167, |
| mipLevel: 2, |
| origin: {x: 19, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 632 */ |
| offset: 632, |
| bytesPerRow: 37888, |
| buffer: buffer187, |
| }, {width: 8, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture266 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView256 = texture89.createView({format: 'r16sint'}); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], sampleCount: 1}); |
| let externalTexture49 = device0.importExternalTexture({source: videoFrame28}); |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup91, new Uint32Array(451), 78, 1); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, -2_096_072_786); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(6, buffer141, 4); |
| } catch {} |
| let pipeline48 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x21e3a74}, |
| fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex4', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 28, |
| attributes: [ |
| {format: 'sint32', offset: 4, shaderLocation: 5}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 6}, |
| {format: 'float16x2', offset: 0, shaderLocation: 13}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 0}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 12}, |
| {format: 'float32x2', offset: 8, shaderLocation: 11}, |
| {format: 'sint32x4', offset: 4, shaderLocation: 15}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 1}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 9}, |
| {format: 'unorm8x4', offset: 12, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 8, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm8x4', offset: 0, shaderLocation: 2}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', unclippedDepth: true}, |
| }); |
| let commandEncoder217 = device0.createCommandEncoder({}); |
| let texture267 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'r32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture268 = device0.createTexture({size: [4, 6, 1], dimension: '3d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView257 = texture161.createView({}); |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 9_989_666); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer35, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer188, 'uint16', 38, 8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 932, new Float16Array(1946).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.451)), 485, 900); |
| } catch {} |
| let promise30 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder218 = device0.createCommandEncoder({}); |
| let texture269 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 20}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup109, new Uint32Array(48), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(154, 0, 457_633_345); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 350_187_616); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(3, buffer43, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer163, 76, new Uint32Array(19509).map((_, i) => i * 8), 2370, 16); |
| } catch {} |
| let gpuCanvasContext15 = canvas9.getContext('webgpu'); |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(69); }; |
| } catch {} |
| let bindGroup114 = device0.createBindGroup({layout: autogeneratedBindGroupLayout16, entries: [{binding: 1, resource: externalTexture18}]}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup98, [0]); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(150, 0, 113_858_270); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup67, []); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup34, new Uint32Array(2359), 168, 1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline48); |
| } catch {} |
| try { |
| renderBundleEncoder16.pushDebugGroup('\u2344'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer60, 8, new BigInt64Array(81).map((_, i) => BigInt(i - 1)), 8, 8); |
| } catch {} |
| let promise31 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, targets: [{format: 'r16sint'}]}, |
| vertex: { |
| module: shaderModule8, |
| entryPoint: 'vertex8', |
| buffers: [ |
| { |
| arrayStride: 40, |
| attributes: [ |
| {format: 'uint32x2', offset: 4, shaderLocation: 0}, |
| {format: 'float16x4', offset: 0, shaderLocation: 2}, |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 10}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 8}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 11}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 5}, |
| {format: 'sint8x2', offset: 14, shaderLocation: 6}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 7}, |
| {format: 'snorm16x2', offset: 16, shaderLocation: 3}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 1}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 12}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 9}, |
| {format: 'float32x2', offset: 0, shaderLocation: 15}, |
| ], |
| }, |
| { |
| arrayStride: 56, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32x2', offset: 0, shaderLocation: 4}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let gpuCanvasContext16 = canvas8.getContext('webgpu'); |
| let imageData34 = new ImageData(16, 32); |
| let commandEncoder219 = device0.createCommandEncoder(); |
| let texture270 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, -1_568_952_390, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer54, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(2, buffer71, 0, 14); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline12); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 996 */ |
| offset: 996, |
| bytesPerRow: 24832, |
| buffer: buffer11, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 14, y: 11, z: 6}, |
| aspect: 'all', |
| }, {width: 18, height: 22, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule13 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| requires packed_4x8_integer_dot_product; |
| |
| var<private> vp13: vec2u = vec2u(422418387, 707025412); |
| |
| @group(1) @binding(384) var<storage, read> buffer198: array<array<array<array<array<VertexInput47, 5>, 1>, 20>, 1>>; |
| |
| struct T3 { |
| @align(16) @size(224) f0: array<array<atomic<u32>, 1>, 16>, |
| @align(16) @size(176) f1: atomic<u32>, |
| } |
| |
| @group(0) @binding(403) var<storage, read_write> buffer197: array<array<array<array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 23>, 1>, 1>, 1>, 1>, 6>, 2>>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentInput29 { |
| @location(13) location_13: f32, |
| @location(10) location_10: i32, |
| } |
| |
| struct T9 { |
| f0: array<atomic<i32>>, |
| } |
| |
| struct VertexInput47 { |
| @location(7) @interpolate(flat, first) location_7: i32, |
| } |
| |
| struct T14 { |
| f0: array<T1>, |
| } |
| |
| struct VertexInput46 { |
| @location(6) location_6: vec2f, |
| @builtin(instance_index) instance_index: u32, |
| @location(14) location_14: vec4h, |
| @location(11) location_11: vec2i, |
| } |
| |
| struct VertexInput50 { |
| @location(8) location_8: vec4f, |
| } |
| |
| @id(59839) override override24: u32; |
| |
| struct T12 { |
| f0: array<u32>, |
| } |
| |
| struct T11 { |
| @align(16) @size(16) f0: vec2h, |
| @align(16) @size(384) f1: i32, |
| } |
| |
| struct T5 { |
| @size(16) f0: f32, |
| f1: array<T1>, |
| } |
| |
| struct VertexInput49 { |
| @location(2) location_2: f16, |
| @location(15) location_15: vec2i, |
| @location(0) location_0: vec2h, |
| @location(13) location_13: vec2i, |
| } |
| |
| struct ComputeInput15 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct T8 { |
| @align(32) f0: array<T1>, |
| } |
| |
| override override23: u32 = (106985133 % 103) + 1; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexInput48 { |
| @location(12) @interpolate(linear, centroid) location_12: vec4h, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct T2 { |
| @align(32) f0: array<atomic<u32>>, |
| } |
| |
| struct FragmentOutput7 { |
| @location(4) @interpolate(flat) location_4: vec4i, |
| @location(2) location_2: vec4u, |
| @location(6) location_6: vec2u, |
| @location(0) location_0: vec4i, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T1 { |
| f0: atomic<u32>, |
| } |
| |
| @group(0) @binding(147) var st19: texture_storage_1d<r32sint, read_write>; |
| |
| @group(0) @binding(6) var<storage, read_write> buffer196: array<array<VertexInput46, 10>>; |
| |
| struct T6 { |
| @align(64) @size(320) f0: f16, |
| } |
| |
| struct T13 { |
| @size(64) f0: T1, |
| f1: array<array<f16, 1>>, |
| } |
| |
| @id(33987) override override25: u32 = (424942892 % 103) + 1; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T0 { |
| @align(32) @size(32) f0: array<atomic<u32>, 1>, |
| f1: array<array<bool, 1>>, |
| } |
| |
| struct T10 { |
| @align(16) f0: array<u32>, |
| } |
| |
| struct T4 { |
| @size(56) f0: vec4h, |
| } |
| |
| struct T7 { |
| @align(8) f0: array<u32>, |
| } |
| |
| /* used global variables: buffer198 */ |
| @vertex |
| fn vertex15(@location(10) location_10: vec4h, a1: VertexInput46, a2: VertexInput47, @location(1) location_1: u32, @builtin(vertex_index) vertex_index: u32, @location(3) location_3: f32, @location(5) @interpolate(flat) location_5: i32, a7: VertexInput48, a8: VertexInput49, @location(4) @interpolate(flat) location_4: i32, a10: VertexInput50, @location(9) @interpolate(flat) location_9: vec2u) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = vec4f(f32((*&buffer198)[unconst_u32(16998908)][unconst_u32(174058672)][19][unconst_u32(335447313)][unconst_u32(22977049)].location_7)); |
| out = vec4f(bitcast<f32>((*&buffer198)[arrayLength(&(*&buffer198))][0][unconst_u32(30703179)][0][4].location_7)); |
| let ptr80: ptr<storage, array<array<VertexInput47, 5>, 1>, read> = &(*&buffer198)[arrayLength(&(*&buffer198))][unconst_u32(1362880946)][19]; |
| return out; |
| _ = buffer198; |
| } |
| |
| /* used global variables: buffer196, buffer197, buffer198, st19 */ |
| @fragment |
| fn fragment12(@location(6) location_6: f16, @location(4) location_4: i32, a2: FragmentInput29) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| vp13 *= vec2u(u32(buffer197[arrayLength(&buffer197)][1][u32((*&buffer197)[unconst_u32(221441958)][unconst_u32(16913016)][unconst_u32(4294967295)][0][unconst_u32(1095109747)][unconst_u32(1044998955)][u32(buffer197[arrayLength(&buffer197)][1][5][unconst_u32(115726339)][u32((*&buffer197)[unconst_u32(178381616)][1][5][0][0][unconst_u32(558396908)][unconst_u32(1242861192)][unconst_u32(906268044)][unconst_u32(815176823)][unconst_u32(2882149905)][0][0])][u32((*&buffer197)[unconst_u32(653722584)][1][unconst_u32(723419293)][unconst_u32(176224133)][0][unconst_u32(3362034615)][unconst_u32(90401192)][22][0][u32(buffer197[unconst_u32(150927811)][u32(buffer197[arrayLength(&buffer197)][1][5][0][0][0][0][22][0][unconst_u32(634153486)][0][unconst_u32(907247963)])][unconst_u32(979410764)][0][u32(buffer197[unconst_u32(358888613)][1][5][unconst_u32(226452645)][0][0][u32(buffer197[arrayLength(&buffer197)][1][unconst_u32(288759037)][0][0][0][unconst_u32(107226809)][unconst_u32(191507140)][0][unconst_u32(101340814)][unconst_u32(567504054)][unconst_u32(760178596)])][22][0][unconst_u32(318031492)][0][0])][0][unconst_u32(92608026)][22][unconst_u32(19617505)][unconst_u32(566767196)][0][0])][unconst_u32(578825088)][0])][unconst_u32(63316019)][unconst_u32(336776553)][unconst_u32(688822951)][0][unconst_u32(7255640)][unconst_u32(509650520)])][22][0][unconst_u32(1357500325)][0][0])][unconst_u32(1184867996)][unconst_u32(2272168514)][0][0][22][unconst_u32(899929861)][unconst_u32(189225928)][0][unconst_u32(900167119)])); |
| let ptr81: ptr<storage, array<f16, 1>, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(11386923)][unconst_u32(1219713681)][unconst_u32(1217232330)][0][0][unconst_u32(505649393)][unconst_u32(314542860)][0][0][unconst_u32(26221625)]; |
| buffer196[unconst_u32(287460475)][unconst_u32(398359397)].instance_index = u32(buffer197[arrayLength(&buffer197)][1][5][0][unconst_u32(89697359)][unconst_u32(1203258525)][0][22][u32((*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(2384329616)][unconst_u32(446624327)][unconst_u32(956069112)][0][0][0][22][unconst_u32(1083921589)][unconst_u32(1301027256)][0][0])][0][0][0]); |
| textureStore(st19, unconst_i32(632777845), vec4i(vec4i(unconst_i32(37583397), unconst_i32(502324684), unconst_i32(155493647), unconst_i32(183957200)))); |
| let ptr82: ptr<storage, f16, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][u32(buffer197[unconst_u32(1320486784)][1][u32((*&buffer197)[unconst_u32(562683643)][unconst_u32(1104429267)][unconst_u32(18079992)][0][0][0][0][22][0][unconst_u32(638018806)][unconst_u32(494521339)][0])][unconst_u32(287160550)][0][unconst_u32(409992023)][unconst_u32(241596118)][22][u32(buffer197[arrayLength(&buffer197)][u32((*&buffer197)[arrayLength(&(*&buffer197))][1][5][unconst_u32(2036443312)][u32((*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(3293223159)][unconst_u32(1481609300)][0][0][unconst_u32(370323124)][0][22][unconst_u32(622419256)][unconst_u32(3250125362)][unconst_u32(736198921)][0])][0][unconst_u32(402148370)][unconst_u32(290277521)][unconst_u32(4294967295)][u32((*&buffer197)[unconst_u32(57723256)][u32((*&buffer198)[unconst_u32(185914121)][u32(buffer197[unconst_u32(355830601)][unconst_u32(744827477)][5][0][unconst_u32(1328357375)][unconst_u32(44089922)][unconst_u32(275795251)][22][unconst_u32(49208221)][0][unconst_u32(412972511)][0])][19][unconst_u32(8232737)][u32((*&buffer197)[arrayLength(&(*&buffer197))][1][5][0][0][0][unconst_u32(137335206)][unconst_u32(1424622783)][unconst_u32(1228410771)][0][unconst_u32(2880640473)][unconst_u32(2162272850)])].location_7)][5][0][unconst_u32(2220306865)][0][0][22][0][0][unconst_u32(528773296)][0])][u32((*&buffer197)[arrayLength(&(*&buffer197))][u32(buffer197[unconst_u32(62084872)][1][5][0][unconst_u32(688600672)][unconst_u32(801041326)][0][22][0][u32((*&buffer197)[unconst_u32(1312547256)][1][unconst_u32(876672645)][0][0][0][0][unconst_u32(654149506)][0][unconst_u32(123378518)][0][0])][0][unconst_u32(408937144)])][5][unconst_u32(323143764)][0][unconst_u32(621563464)][u32((*&buffer197)[arrayLength(&(*&buffer197))][1][5][0][unconst_u32(465395981)][0][unconst_u32(1976492096)][22][unconst_u32(817091919)][0][unconst_u32(669690714)][unconst_u32(579368351)])][unconst_u32(472006661)][0][unconst_u32(88622457)][0][0])][0])][5][unconst_u32(89984439)][unconst_u32(519885362)][0][unconst_u32(12571726)][22][0][0][unconst_u32(607688123)][0])][0][0][0])][5][0][0][unconst_u32(1287532125)][0][22][unconst_u32(571733851)][0][0][0]; |
| let ptr83: ptr<storage, array<f16, 1>, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(203158769)][5][0][unconst_u32(1172651426)][0][0][22][unconst_u32(287881695)][0][unconst_u32(743003166)]; |
| return out; |
| _ = buffer197; |
| _ = buffer196; |
| _ = buffer198; |
| _ = st19; |
| } |
| |
| /* used global variables: buffer196, buffer197 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute12(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(num_workgroups) num_workgroups: vec3u, a4: ComputeInput15) { |
| vp13 ^= vec2u(u32((*&buffer197)[unconst_u32(802062780)][unconst_u32(1183527467)][5][unconst_u32(81530408)][unconst_u32(416357758)][u32(buffer197[arrayLength(&buffer197)][1][5][unconst_u32(260776411)][unconst_u32(407466382)][0][unconst_u32(1074654428)][22][unconst_u32(332083243)][0][unconst_u32(1509224483)][unconst_u32(75820438)])][0][22][0][unconst_u32(23820030)][0][0])); |
| var vf145: f16 = length(vec3h(unconst_f16(7076.6), unconst_f16(-19308.9), unconst_f16(1236.3))); |
| buffer196[unconst_u32(1437432044)][unconst_u32(713354742)].location_6 = vec2f(f32(buffer197[unconst_u32(5668098)][1][5][unconst_u32(970824482)][unconst_u32(77370481)][unconst_u32(1972792225)][0][unconst_u32(455926681)][unconst_u32(1880568413)][u32(buffer197[unconst_u32(515053142)][unconst_u32(240202516)][unconst_u32(2691367968)][unconst_u32(413068994)][unconst_u32(982240911)][unconst_u32(3773028068)][unconst_u32(714343348)][22][unconst_u32(72454852)][0][0][0])][unconst_u32(668319458)][unconst_u32(1104069874)])); |
| let ptr84: ptr<storage, f16, read_write> = &buffer197[unconst_u32(291326630)][unconst_u32(93117255)][unconst_u32(275955769)][0][0][unconst_u32(1792898584)][0][22][0][0][0][unconst_u32(2079001953)]; |
| let ptr85: ptr<storage, f16, read_write> = &(*&buffer197)[arrayLength(&(*&buffer197))][unconst_u32(117028047)][5][unconst_u32(717472310)][0][unconst_u32(148750343)][unconst_u32(454556681)][22][0][unconst_u32(439106189)][unconst_u32(1467895981)][unconst_u32(284719156)]; |
| let ptr86: ptr<storage, f16, read_write> = &buffer197[arrayLength(&buffer197)][unconst_u32(615188646)][5][unconst_u32(539305020)][0][unconst_u32(207215257)][unconst_u32(2414792303)][u32(buffer197[arrayLength(&buffer197)][unconst_u32(650243486)][unconst_u32(30850109)][0][unconst_u32(44593920)][0][0][22][unconst_u32(1651804825)][0][0][0])][0][0][unconst_u32(162109709)][unconst_u32(106890252)]; |
| let ptr87: ptr<storage, f16, read_write> = &buffer197[arrayLength(&buffer197)][1][unconst_u32(379489087)][0][unconst_u32(657630847)][0][unconst_u32(476096592)][22][unconst_u32(144938745)][0][unconst_u32(1029440309)][unconst_u32(571045900)]; |
| _ = buffer196; |
| _ = buffer197; |
| }`, |
| }); |
| let pipelineLayout5 = device0.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout19, veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout12], |
| }); |
| let commandEncoder220 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup49, []); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(29, 0, 398_889_492); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer68, 36); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer136, 'uint32', 4, 5); |
| } catch {} |
| let texture271 = device0.createTexture({ |
| size: [195, 120, 112], |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView258 = texture93.createView({dimension: '2d-array'}); |
| let renderPassEncoder30 = commandEncoder213.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView255, |
| depthSlice: 52, |
| clearValue: { r: 949.3, g: -508.2, b: -427.5, a: -369.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder11.drawIndirect(buffer94, 4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder20.insertDebugMarker('\u0e75'); |
| } catch {} |
| let commandEncoder221 = device0.createCommandEncoder({}); |
| let textureView259 = texture220.createView({}); |
| let textureView260 = texture49.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer136, 8); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer106, 'uint16', 42, 7); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline40); |
| } catch {} |
| try { |
| commandEncoder134.copyBufferToBuffer(buffer43, 20, buffer153, 40, 0); |
| } catch {} |
| let bindGroup115 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer21, size: 1576}}, |
| {binding: 6, resource: {buffer: buffer109}}, |
| {binding: 3, resource: textureView3}, |
| {binding: 43, resource: {buffer: buffer179}}, |
| ], |
| }); |
| let commandEncoder222 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder11.drawIndexed(2, 0, 0, 1_168_559_985); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer137, 'uint32', 0, 9); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline39); |
| } catch {} |
| try { |
| renderBundleEncoder16.popDebugGroup(); |
| } catch {} |
| try { |
| renderPassEncoder22.insertDebugMarker('\u6171'); |
| } catch {} |
| let commandEncoder223 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder11.end(); |
| } catch {} |
| try { |
| renderBundleEncoder25.insertDebugMarker('\u{1fea4}'); |
| } catch {} |
| let bindGroup116 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 212, resource: textureView26}, |
| {binding: 1, resource: textureView76}, |
| {binding: 14, resource: {buffer: buffer90, size: 437}}, |
| {binding: 39, resource: textureView3}, |
| {binding: 11, resource: {buffer: buffer174}}, |
| {binding: 3, resource: {buffer: buffer20}}, |
| {binding: 33, resource: textureView13}, |
| {binding: 7, resource: externalTexture22}, |
| ], |
| }); |
| let commandEncoder224 = device0.createCommandEncoder({}); |
| let textureView261 = texture174.createView({dimension: '2d-array', aspect: 'all', arrayLayerCount: 1}); |
| let sampler34 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'nearest'}); |
| try { |
| renderBundleEncoder28.setBindGroup(3, bindGroup104, new Uint32Array(202), 12, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: {x: 41, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(41).fill(69), /* required buffer size: 41 */ |
| {offset: 41, bytesPerRow: 163, rowsPerImage: 62}, {width: 61, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline49 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule4, |
| targets: [{format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 40, |
| attributes: [ |
| {format: 'sint8x4', offset: 12, shaderLocation: 13}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 7}, |
| {format: 'float16x2', offset: 4, shaderLocation: 6}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 6, shaderLocation: 2}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 12}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 4}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 9}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 15}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint16x4', offset: 20, shaderLocation: 1}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'float32x3', offset: 0, shaderLocation: 11}, |
| {format: 'float32', offset: 4, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm10-10-10-2', offset: 0, shaderLocation: 14}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let texture272 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 2}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture273 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 349}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r16sint'], |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup13); |
| } catch {} |
| await gc(); |
| let commandEncoder225 = device0.createCommandEncoder({}); |
| let texture274 = device0.createTexture({ |
| size: {width: 4, height: 6, depthOrArrayLayers: 1}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup116, new Uint32Array(1549), 279, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer108, 'uint32', 4, 5); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer100, 'uint16', 22, 24); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| await promise30; |
| } catch {} |
| let img7 = await imageWithData(5, 48, '#10101010', '#20202020'); |
| let imageData35 = new ImageData(28, 40); |
| let bindGroup117 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [{binding: 3, resource: textureView3}, {binding: 1, resource: externalTexture13}], |
| }); |
| let textureView262 = texture272.createView({dimension: '3d'}); |
| let texture275 = device0.createTexture({ |
| size: [32, 48, 8], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView263 = texture35.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder0.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup30, new Uint32Array(962), 70, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer199 = device0.createBuffer({size: 141, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let commandEncoder226 = device0.createCommandEncoder({}); |
| let texture276 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture277 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 478}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder27.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer156, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer101, 0, new DataView(new Uint8Array(4638).map((_, i) => i).buffer), 880, 32); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 7, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(513).fill(49), /* required buffer size: 513 */ |
| {offset: 513}, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise32 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| let bindGroup118 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 33, resource: textureView38}, |
| {binding: 5, resource: textureView53}, |
| {binding: 9, resource: {buffer: buffer146}}, |
| {binding: 40, resource: externalTexture28}, |
| {binding: 255, resource: {buffer: buffer37}}, |
| {binding: 7, resource: textureView4}, |
| {binding: 45, resource: externalTexture17}, |
| {binding: 0, resource: {buffer: buffer35}}, |
| {binding: 2, resource: {buffer: buffer36, offset: 0}}, |
| {binding: 6, resource: textureView76}, |
| {binding: 11, resource: {buffer: buffer21, size: 3304}}, |
| {binding: 84, resource: {buffer: buffer116}}, |
| {binding: 264, resource: textureView36}, |
| {binding: 219, resource: textureView3}, |
| {binding: 210, resource: {buffer: buffer21, size: 2672}}, |
| {binding: 3, resource: {buffer: buffer21, size: 136}}, |
| {binding: 269, resource: textureView160}, |
| {binding: 117, resource: {buffer: buffer21, size: 1596}}, |
| {binding: 211, resource: {buffer: buffer179}}, |
| {binding: 148, resource: textureView54}, |
| {binding: 284, resource: textureView59}, |
| {binding: 386, resource: textureView174}, |
| {binding: 201, resource: {buffer: buffer21, size: 2184}}, |
| ], |
| }); |
| let commandEncoder227 = device0.createCommandEncoder({}); |
| let textureView264 = texture220.createView({dimension: '2d-array'}); |
| let computePassEncoder29 = commandEncoder156.beginComputePass(); |
| let externalTexture50 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup105, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline27); |
| } catch {} |
| try { |
| commandEncoder227.insertDebugMarker('\u02d3'); |
| } catch {} |
| let commandEncoder228 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder21.setBindGroup(2, bindGroup19, new Uint32Array(3889), 246, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(188.89976216528652, 238.3869768454004, 126.7319000309916, 0.25484873487730697, 0.8989803086615178, 0.992881062677733); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let autogeneratedBindGroupLayout27 = pipeline3.getBindGroupLayout(0); |
| let bindGroup119 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 58, resource: {buffer: buffer37}}, {binding: 6, resource: {buffer: buffer111, size: 36}}], |
| }); |
| let commandEncoder229 = device0.createCommandEncoder({}); |
| let externalTexture51 = device0.importExternalTexture({source: videoFrame15}); |
| try { |
| renderPassEncoder19.setVertexBuffer(0, buffer96); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer131, 'uint16', 4, 10); |
| } catch {} |
| try { |
| buffer183.unmap(); |
| } catch {} |
| try { |
| commandEncoder130.resolveQuerySet(querySet0, 110, 0, buffer141, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer56, 104, new Uint32Array(3811).map((_, i) => i * 8), 389, 220); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 34, y: 20, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(13_227).fill(56), /* required buffer size: 13_227 */ |
| {offset: 207, bytesPerRow: 36, rowsPerImage: 40}, {width: 12, height: 2, depthOrArrayLayers: 10}); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup74, new Uint32Array(241), 56, 0); |
| } catch {} |
| let bindGroup120 = device0.createBindGroup({ |
| label: '\u0bd4\u8882\u19eb\ua311', |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer107}}, |
| {binding: 6, resource: {buffer: buffer133, offset: 0, size: 20}}, |
| {binding: 3, resource: textureView3}, |
| {binding: 43, resource: {buffer: buffer51}}, |
| ], |
| }); |
| let buffer200 = device0.createBuffer({size: 206, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let commandBuffer10 = commandEncoder54.finish(); |
| let textureView265 = texture185.createView({dimension: 'cube-array', format: 'r16sint', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let textureView266 = texture57.createView({}); |
| let externalTexture52 = device0.importExternalTexture({source: videoFrame31}); |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer117, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer120, 12, new BigInt64Array(8472).map((_, i) => BigInt(i - 0)), 15, 4); |
| } catch {} |
| let autogeneratedBindGroupLayout28 = pipeline47.getBindGroupLayout(0); |
| let bindGroup121 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout22, |
| entries: [{binding: 6, resource: {buffer: buffer70}}, {binding: 58, resource: {buffer: buffer107}}], |
| }); |
| try { |
| renderPassEncoder26.setVertexBuffer(0, buffer146, 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup106, [0]); |
| } catch {} |
| let commandEncoder230 = device0.createCommandEncoder(); |
| let texture278 = gpuCanvasContext2.getCurrentTexture(); |
| try { |
| renderPassEncoder19.drawIndexedIndirect(buffer144, 20); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer54, 12); |
| } catch {} |
| let autogeneratedBindGroupLayout29 = pipeline28.getBindGroupLayout(0); |
| let textureView267 = texture63.createView({aspect: 'all'}); |
| let sampler35 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 57.11, maxAnisotropy: 1}); |
| try { |
| commandEncoder119.copyTextureToBuffer({ |
| texture: texture255, |
| mipLevel: 0, |
| origin: {x: 53, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5648 */ |
| offset: 5648, |
| bytesPerRow: 17408, |
| rowsPerImage: 7, |
| buffer: buffer91, |
| }, {width: 11, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 14, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 69, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout30 = pipeline37.getBindGroupLayout(0); |
| let commandEncoder231 = device0.createCommandEncoder({}); |
| let textureView268 = texture274.createView({aspect: 'all', baseArrayLayer: 0}); |
| let textureView269 = texture267.createView({baseArrayLayer: 6, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup118, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder19.draw(0, 203, 0, 2_590_725_446); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer102, 4); |
| } catch {} |
| try { |
| buffer173.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture205, |
| mipLevel: 0, |
| origin: {x: 67, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(162).fill(29), /* required buffer size: 162 */ |
| {offset: 162, bytesPerRow: 362}, {width: 159, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise33 = device0.queue.onSubmittedWorkDone(); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup0, new Uint32Array(2780), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.drawIndirect(buffer59, 8); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer90, 'uint32', 56, 106); |
| } catch {} |
| let computePassEncoder30 = commandEncoder99.beginComputePass(); |
| try { |
| computePassEncoder30.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder19.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline26); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d' }, |
| }, |
| {binding: 40, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 70, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 161, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup122 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 212, resource: textureView241}, |
| {binding: 7, resource: externalTexture1}, |
| {binding: 1, resource: textureView76}, |
| {binding: 39, resource: textureView17}, |
| {binding: 11, resource: {buffer: buffer141}}, |
| {binding: 14, resource: {buffer: buffer56}}, |
| {binding: 3, resource: {buffer: buffer103}}, |
| {binding: 33, resource: textureView13}, |
| ], |
| }); |
| let buffer201 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder232 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup31); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToBuffer(buffer43, 0, buffer132, 20, 0); |
| } catch {} |
| let bindGroup123 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []}); |
| let commandEncoder233 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup88); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer69, 'uint32', 40, 188); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer112, 'uint16', 22, 1); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer159, 0, new Float64Array(9773).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/9772)), 1525, 8); |
| } catch {} |
| let bindGroup124 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 184, resource: {buffer: buffer136}}, |
| {binding: 0, resource: {buffer: buffer56}}, |
| {binding: 5, resource: sampler22}, |
| {binding: 1, resource: sampler31}, |
| {binding: 365, resource: textureView218}, |
| {binding: 48, resource: textureView3}, |
| {binding: 32, resource: externalTexture4}, |
| ], |
| }); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer52, 'uint16', 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(5, buffer139, 76, 13); |
| } catch {} |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 241, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 290, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 348, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 556, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 711, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let textureView270 = texture36.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup24, new Uint32Array(2823), 382, 1); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u{1faa0}'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| let commandBuffer11 = commandEncoder68.finish({}); |
| let texture279 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| commandEncoder177.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 32 */ |
| offset: 32, |
| bytesPerRow: 36352, |
| buffer: buffer0, |
| }, { |
| texture: texture276, |
| mipLevel: 1, |
| origin: {x: 13, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas9, |
| origin: { x: 16, y: 20 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 37, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 23, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView271 = texture220.createView({baseMipLevel: 0}); |
| try { |
| commandEncoder71.clearBuffer(buffer76); |
| } catch {} |
| let commandEncoder234 = device0.createCommandEncoder({}); |
| let texture280 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer160, 0, 23); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer9, 'uint16', 6, 8); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline41); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer11]); |
| } catch {} |
| let promise34 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 97, height: 60, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 18, y: 14, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame37 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'linear'} }); |
| let bindGroup125 = device0.createBindGroup({layout: autogeneratedBindGroupLayout14, entries: []}); |
| let texture281 = device0.createTexture({ |
| size: [16, 24, 4], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture53 = device0.importExternalTexture({source: videoFrame22}); |
| let bindGroup126 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 138, resource: textureView128}, |
| {binding: 0, resource: externalTexture49}, |
| {binding: 1, resource: externalTexture24}, |
| ], |
| }); |
| let textureView272 = texture56.createView({dimension: '2d-array'}); |
| try { |
| device0.queue.writeBuffer(buffer120, 0, new Float32Array(30271).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.200)), 6305, 8); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(33); }; |
| } catch {} |
| let buffer202 = device0.createBuffer({size: 272, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder235 = device0.createCommandEncoder({}); |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let texture282 = device0.createTexture({ |
| size: [390, 24, 1], |
| mipLevelCount: 3, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup63, new Uint32Array(877), 231, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture134, |
| mipLevel: 1, |
| origin: {x: 10, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(118).fill(170), /* required buffer size: 118 */ |
| {offset: 118, bytesPerRow: 448}, {width: 186, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout31 = pipeline47.getBindGroupLayout(0); |
| let bindGroup127 = device0.createBindGroup({layout: autogeneratedBindGroupLayout21, entries: [{binding: 1, resource: externalTexture27}]}); |
| let commandEncoder236 = device0.createCommandEncoder({}); |
| let texture283 = device0.createTexture({ |
| label: '\u0c5a\u3e04\u61b7\u0cca\u0686\u{1f708}\u{1f8c0}\uc2bd\u3739\u0a46', |
| size: [390, 24, 1], |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16uint'], |
| }); |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup67); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer69, 'uint16', 38, 18); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(1, buffer107); |
| } catch {} |
| try { |
| commandEncoder128.copyTextureToBuffer({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 16, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 520 widthInBlocks: 130 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 180 */ |
| offset: 180, |
| bytesPerRow: 9472, |
| buffer: buffer184, |
| }, {width: 130, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer203 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| let texture284 = device0.createTexture({ |
| size: [195, 120, 1605], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup33, new Uint32Array(1436), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer100, 'uint16', 10, 3); |
| } catch {} |
| try { |
| commandEncoder74.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 0 */ |
| offset: 0, |
| bytesPerRow: 28416, |
| buffer: buffer142, |
| }, { |
| texture: texture206, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| document.body.prepend(canvas4); |
| let bindGroup128 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 6, resource: {buffer: buffer158}}, {binding: 58, resource: {buffer: buffer107}}], |
| }); |
| let texture285 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup104); |
| } catch {} |
| try { |
| commandEncoder86.insertDebugMarker('\ue52f'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer184, 32, new Float16Array(2497).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.689)), 110, 24); |
| } catch {} |
| let bindGroup129 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [{binding: 69, resource: textureView118}, {binding: 14, resource: textureView245}], |
| }); |
| let texture286 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderBundleEncoder18.setBindGroup(0, bindGroup106, new Uint32Array(2927), 91, 1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(2, buffer59, 0); |
| } catch {} |
| let buffer204 = device0.createBuffer({ |
| size: 223, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView273 = texture34.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline14); |
| } catch {} |
| try { |
| buffer108.unmap(); |
| } catch {} |
| let img8 = await imageWithData(39, 19, '#10101010', '#20202020'); |
| let autogeneratedBindGroupLayout32 = pipeline20.getBindGroupLayout(2); |
| let buffer205 = device0.createBuffer({size: 348, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder237 = device0.createCommandEncoder(); |
| let texture287 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture288 = device0.createTexture({ |
| size: {width: 390, height: 240, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder4.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup129, new Uint32Array(1127), 165, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.insertDebugMarker('\u3322'); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(6); }; |
| } catch {} |
| let bindGroup130 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout9, |
| entries: [{binding: 1, resource: externalTexture29}, {binding: 3, resource: textureView3}], |
| }); |
| let commandEncoder238 = device0.createCommandEncoder(); |
| let textureView274 = texture287.createView({dimension: '2d-array'}); |
| let texture289 = device0.createTexture({ |
| size: [780, 480, 1], |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup105, [0]); |
| } catch {} |
| try { |
| await promise34; |
| } catch {} |
| document.body.append(img0); |
| let bindGroup131 = device0.createBindGroup({layout: autogeneratedBindGroupLayout18, entries: [{binding: 1, resource: externalTexture46}]}); |
| let commandEncoder239 = device0.createCommandEncoder(); |
| let textureView275 = texture212.createView({dimension: 'cube', aspect: 'all', baseArrayLayer: 1}); |
| let texture290 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 13}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView276 = texture279.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| buffer57.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(20); }; |
| } catch {} |
| let commandEncoder240 = device0.createCommandEncoder({}); |
| let texture291 = device0.createTexture({ |
| size: [8, 12, 2], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView277 = texture92.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup18, new Uint32Array(5274), 90, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(3, buffer62, 0, 4); |
| } catch {} |
| let buffer206 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView278 = texture4.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer112, 'uint32', 0, 26); |
| } catch {} |
| let videoFrame38 = new VideoFrame(videoFrame20, {timestamp: 0}); |
| let textureView279 = texture34.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer74, 'uint16', 0, 86); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, buffer154, 36); |
| } catch {} |
| let buffer207 = device0.createBuffer({size: 357, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder241 = device0.createCommandEncoder(); |
| let textureView280 = texture188.createView({dimension: '2d', format: 'astc-5x5-unorm-srgb', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder17.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup127); |
| } catch {} |
| try { |
| commandEncoder210.resolveQuerySet(querySet1, 338, 1, buffer57, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer184, 128, new DataView(new Uint8Array(34037).map((_, i) => i).buffer), 6151, 4); |
| } catch {} |
| let bindGroup132 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []}); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup72, new Uint32Array(12), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder6.draw(0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer19, 'uint32', 0, 25); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView281 = texture161.createView({dimension: '1d'}); |
| let renderBundle3 = renderBundleEncoder6.finish({}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup78); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer1, 'uint16', 46, 35); |
| } catch {} |
| document.body.prepend(canvas5); |
| let buffer208 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup90, new Uint32Array(46), 4, 2); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| try { |
| await promise33; |
| } catch {} |
| let texture292 = device0.createTexture({ |
| size: {width: 1560, height: 96, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let textureView282 = texture197.createView({}); |
| try { |
| renderPassEncoder16.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer137, 0, new Float16Array(15680).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.568)), 413, 8); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 2, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 9, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 33, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 40, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 45, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 84, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 117, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 148, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 201, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 210, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 211, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 219, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 255, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 264, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 269, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 284, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 386, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup58, [0]); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer188, 'uint16', 234, 3); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer65, 'uint16', 0, 3); |
| } catch {} |
| let commandEncoder242 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup22, new Uint32Array(2475), 305, 1); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer65, 'uint32', 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline27); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture218, |
| mipLevel: 0, |
| origin: {x: 252, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(25).fill(121), /* required buffer size: 25 */ |
| {offset: 25}, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(9); }; |
| } catch {} |
| let buffer209 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture293 = device0.createTexture({ |
| size: [195, 120, 1], |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView283 = texture293.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer144, 'uint16', 12, 1); |
| } catch {} |
| try { |
| commandEncoder79.copyBufferToBuffer(buffer143, 8, buffer208, 8, 4); |
| } catch {} |
| document.body.append(img1); |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout4, veryExplicitBindGroupLayout9]}); |
| let texture294 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView284 = texture9.createView({dimension: '2d-array', aspect: 'all'}); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup95, new Uint32Array(1904), 962, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 24, new Float32Array(334).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.689)), 26, 4); |
| } catch {} |
| let bindGroup133 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 5, resource: sampler13}, |
| {binding: 1, resource: sampler5}, |
| {binding: 48, resource: textureView0}, |
| {binding: 0, resource: {buffer: buffer107}}, |
| {binding: 184, resource: {buffer: buffer176}}, |
| {binding: 365, resource: textureView249}, |
| {binding: 32, resource: externalTexture39}, |
| ], |
| }); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup3, new Uint32Array(2085), 91, 1); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer9, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline40); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer71); |
| } catch {} |
| let bindGroup134 = device0.createBindGroup({layout: autogeneratedBindGroupLayout17, entries: []}); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup33); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(12); }; |
| } catch {} |
| let commandEncoder243 = device0.createCommandEncoder({}); |
| let pipeline50 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule12, entryPoint: 'compute10', constants: {}}}); |
| let offscreenCanvas8 = new OffscreenCanvas(63, 107); |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let buffer210 = device0.createBuffer({size: 252, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup47, new Uint32Array(971), 98, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline38); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder232.clearBuffer(buffer66); |
| } catch {} |
| try { |
| commandEncoder60.resolveQuerySet(querySet1, 172, 11, buffer76, 0); |
| } catch {} |
| try { |
| commandEncoder216.insertDebugMarker('\u05b9'); |
| } catch {} |
| let promise35 = device0.queue.onSubmittedWorkDone(); |
| let pipeline51 = await promise21; |
| let bindGroup135 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [{binding: 6, resource: {buffer: buffer158, offset: 0}}, {binding: 58, resource: {buffer: buffer107}}], |
| }); |
| let buffer211 = device0.createBuffer({size: 33, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer1, 'uint32', 132, 85); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer156, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer63, 'uint32', 28, 30); |
| } catch {} |
| let gpuCanvasContext17 = offscreenCanvas8.getContext('webgpu'); |
| let buffer212 = device0.createBuffer({size: 348, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup117); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndexedIndirect(buffer109, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndirect(buffer22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(2, buffer9, 0); |
| } catch {} |
| let promise36 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup136 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [{binding: 3, resource: textureView17}, {binding: 1, resource: externalTexture12}], |
| }); |
| try { |
| renderBundleEncoder17.setBindGroup(1, bindGroup43, new Uint32Array(2661), 979, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.draw(306, 0, 636_222_935); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndexed(2, 0, 0, -1_831_901_914); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndirect(buffer200, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer131, 'uint16', 30, 79); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(6, buffer137); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup24, new Uint32Array(333), 19, 1); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndexed(2, 0, 1, 657_832_087, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndirect(buffer68, 20); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let pipeline52 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule11, constants: {}}}); |
| let bindGroup137 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [{binding: 69, resource: textureView63}, {binding: 14, resource: textureView118}], |
| }); |
| let texture295 = device0.createTexture({ |
| size: [32], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup134, new Uint32Array(3991), 910, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(0, buffer68, 80); |
| } catch {} |
| let commandEncoder244 = device0.createCommandEncoder({}); |
| let renderBundle4 = renderBundleEncoder26.finish(); |
| try { |
| renderPassEncoder28.setVertexBuffer(3, buffer136, 12, 36); |
| } catch {} |
| try { |
| buffer159.unmap(); |
| } catch {} |
| try { |
| commandEncoder144.copyTextureToBuffer({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 2, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 340 */ |
| offset: 340, |
| bytesPerRow: 34048, |
| buffer: buffer132, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup138 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout23, |
| entries: [ |
| {binding: 7, resource: textureView35}, |
| {binding: 255, resource: {buffer: buffer116}}, |
| {binding: 6, resource: textureView76}, |
| {binding: 284, resource: textureView115}, |
| {binding: 386, resource: textureView245}, |
| {binding: 45, resource: externalTexture35}, |
| {binding: 264, resource: textureView54}, |
| {binding: 9, resource: {buffer: buffer80}}, |
| {binding: 3, resource: {buffer: buffer204, size: 128}}, |
| {binding: 219, resource: textureView0}, |
| {binding: 5, resource: textureView220}, |
| {binding: 33, resource: textureView270}, |
| {binding: 117, resource: {buffer: buffer21, size: 2824}}, |
| {binding: 210, resource: {buffer: buffer21, size: 1608}}, |
| {binding: 211, resource: {buffer: buffer179}}, |
| {binding: 201, resource: {buffer: buffer21, size: 1024}}, |
| {binding: 84, resource: {buffer: buffer116}}, |
| {binding: 2, resource: {buffer: buffer156, offset: 0}}, |
| {binding: 269, resource: textureView160}, |
| {binding: 40, resource: externalTexture15}, |
| {binding: 148, resource: textureView54}, |
| {binding: 0, resource: {buffer: buffer210, size: 89}}, |
| {binding: 11, resource: {buffer: buffer21, size: 3268}}, |
| ], |
| }); |
| let buffer213 = device0.createBuffer({size: 160, usage: GPUBufferUsage.COPY_SRC}); |
| let textureView285 = texture141.createView({dimension: '3d'}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup92, new Uint32Array(828), 47, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer131, 'uint16', 74, 57); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline31); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer214 = device0.createBuffer({size: 1024, usage: GPUBufferUsage.COPY_SRC}); |
| let texture296 = device0.createTexture({ |
| size: [195], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16sint'], |
| }); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer53, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup43, new Uint32Array(1128), 191, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline51); |
| } catch {} |
| try { |
| buffer70.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 3, y: 5, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(20).fill(129), /* required buffer size: 20 */ |
| {offset: 20, bytesPerRow: 72, rowsPerImage: 89}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 49, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer215 = device0.createBuffer({size: 76, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder245 = device0.createCommandEncoder({}); |
| let texture297 = device0.createTexture({ |
| size: [195, 120, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup122); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer71); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline20); |
| } catch {} |
| try { |
| commandEncoder172.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2834 */ |
| offset: 2834, |
| bytesPerRow: 9984, |
| buffer: buffer118, |
| }, { |
| texture: texture177, |
| mipLevel: 2, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 40, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder75.resolveQuerySet(querySet0, 71, 0, buffer190, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture212, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(55).fill(93), /* required buffer size: 55 */ |
| {offset: 55}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas4, |
| origin: { x: 6, y: 20 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 6, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 86, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let videoFrame39 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'smpteSt4281'} }); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup108); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer202, 8, new BigInt64Array(6049).map((_, i) => BigInt(i - 3)), 397, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 4, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 211, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 0, new Float32Array(13928).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9632)), 1393, 0); |
| } catch {} |
| let pipeline53 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1}}); |
| try { |
| gpuCanvasContext10.unconfigure(); |
| } catch {} |
| let autogeneratedBindGroupLayout33 = pipeline22.getBindGroupLayout(0); |
| let texture298 = device0.createTexture({ |
| size: {width: 195, height: 120, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder31 = commandEncoder91.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView172, |
| clearValue: { r: -761.9, g: 562.0, b: 46.75, a: -666.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderBundleEncoder23.setPipeline(pipeline49); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(95); }; |
| } catch {} |
| let buffer216 = device0.createBuffer({size: 352, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup107); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup13, new Uint32Array(754), 127, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(6, buffer199, 12, 9); |
| } catch {} |
| try { |
| await buffer159.mapAsync(GPUMapMode.READ, 0, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| try { |
| await promise32; |
| } catch {} |
| let buffer217 = device0.createBuffer({size: 260, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder246 = device0.createCommandEncoder({}); |
| let textureView286 = texture246.createView({dimension: 'cube', aspect: 'all', format: 'r32float', baseArrayLayer: 1}); |
| try { |
| renderPassEncoder6.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup85, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer137, 'uint32', 0, 5); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 508 widthInBlocks: 254 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2972 */ |
| offset: 2972, |
| bytesPerRow: 15872, |
| buffer: buffer118, |
| }, { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 73, y: 247, z: 0}, |
| aspect: 'all', |
| }, {width: 254, height: 35, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img2); |
| let commandEncoder247 = device0.createCommandEncoder(); |
| let textureView287 = texture109.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder15.setPipeline(pipeline26); |
| } catch {} |
| try { |
| await buffer173.mapAsync(GPUMapMode.READ); |
| } catch {} |
| document.body.prepend(canvas0); |
| let commandEncoder248 = device0.createCommandEncoder({}); |
| let texture299 = device0.createTexture({ |
| size: [2, 2, 14], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup6, new Uint32Array(546), 62, 1); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(2, buffer143); |
| } catch {} |
| let autogeneratedBindGroupLayout34 = pipeline50.getBindGroupLayout(0); |
| let commandEncoder249 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder6.setBindGroup(3, bindGroup66, [0]); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder250 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder26.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup44, new Uint32Array(1021), 161, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(6, buffer154); |
| } catch {} |
| try { |
| commandEncoder192.copyBufferToBuffer(buffer117, 16, buffer103, 28, 8); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(14); }; |
| } catch {} |
| let buffer218 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder251 = device0.createCommandEncoder({}); |
| let texture300 = device0.createTexture({ |
| size: [97, 60, 238], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler36 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 94.78, |
| compare: 'always', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup59); |
| } catch {} |
| let textureView288 = texture181.createView({dimension: '2d-array', format: 'rgba8snorm', mipLevelCount: 1}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup135); |
| } catch {} |
| try { |
| adapter0.label = '\u{1ff0d}\u{1faf3}\u{1f786}\u0264\u7e90'; |
| } catch {} |
| let buffer219 = device0.createBuffer({size: 52, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder252 = device0.createCommandEncoder({}); |
| let texture301 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder25.setBindGroup(0, bindGroup123); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer78, 0, new Float64Array(7050).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/7046)), 548, 0); |
| } catch {} |
| try { |
| globalThis.someLabel = textureView176.label; |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(2, bindGroup102, new Uint32Array(4293), 30, 1); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder57.resolveQuerySet(querySet1, 107, 1, buffer204, 0); |
| } catch {} |
| try { |
| commandEncoder247.pushDebugGroup('\u0ee8'); |
| } catch {} |
| try { |
| externalTexture50.label = '\u0ed8\u943a\u{1fa7b}\u{1ffac}\u5575\u0cbf\ud1ae\u{1fc74}'; |
| } catch {} |
| let texture302 = device0.createTexture({size: {width: 97}, dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| let sampler37 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 60.14, |
| }); |
| let externalTexture54 = device0.importExternalTexture({source: videoFrame27, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup3, [0]); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(0, buffer146); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 0, new Float32Array(3125).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.104)), 15, 16); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(4).fill(83), /* required buffer size: 4 */ |
| {offset: 4, bytesPerRow: 18}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup139 = device0.createBindGroup({layout: autogeneratedBindGroupLayout19, entries: []}); |
| let buffer220 = device0.createBuffer({size: 128, usage: GPUBufferUsage.INDIRECT}); |
| let texture303 = device0.createTexture({ |
| size: [32, 48, 8], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler38 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 99.79, compare: 'never'}); |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer193, 28, 12); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline31); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(67); }; |
| } catch {} |
| let imageData36 = new ImageData(16, 20); |
| let commandEncoder253 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder20.beginOcclusionQuery(373); |
| } catch {} |
| try { |
| gpuCanvasContext15.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 138, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup140 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: []}); |
| let commandEncoder254 = device0.createCommandEncoder({}); |
| let sampler39 = device0.createSampler({addressModeU: 'repeat', minFilter: 'linear', lodMaxClamp: 77.07, maxAnisotropy: 1}); |
| try { |
| renderPassEncoder5.setVertexBuffer(5, buffer96, 56); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder236.pushDebugGroup('\u0ff6'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer201, 64, new DataView(new Uint8Array(25796).map((_, i) => i).buffer), 1811, 0); |
| } catch {} |
| let bindGroup141 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 6, resource: {buffer: buffer111, size: 20}}, |
| {binding: 43, resource: {buffer: buffer79}}, |
| {binding: 58, resource: {buffer: buffer107}}, |
| {binding: 3, resource: textureView3}, |
| ], |
| }); |
| let buffer221 = device0.createBuffer({size: 224, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer55, 'uint32', 3_084, 1_836); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder173.resolveQuerySet(querySet0, 34, 28, buffer187, 0); |
| } catch {} |
| try { |
| computePassEncoder30.insertDebugMarker('\u4e04'); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer216, 12, new DataView(new ArrayBuffer(172288)), 5374, 4); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup88, new Uint32Array(358), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(2, bindGroup23, new Uint32Array(939), 334, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer63, 'uint16', 38, 58); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(4, buffer141, 0); |
| } catch {} |
| let autogeneratedBindGroupLayout35 = pipeline43.getBindGroupLayout(0); |
| let bindGroup142 = device0.createBindGroup({layout: autogeneratedBindGroupLayout35, entries: [{binding: 138, resource: textureView121}]}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 2, depthOrArrayLayers: 14} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture246, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder255 = device0.createCommandEncoder({}); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture180, |
| mipLevel: 0, |
| origin: {x: 12, y: 10, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(69).fill(119), /* required buffer size: 69 */ |
| {offset: 69, bytesPerRow: 242}, {width: 90, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 2, depthOrArrayLayers: 14} |
| */ |
| { |
| source: offscreenCanvas5, |
| origin: { x: 0, y: 16 }, |
| flipY: false, |
| }, { |
| texture: texture246, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 6}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData37 = new ImageData(84, 4); |
| try { |
| computePassEncoder3.setPipeline(pipeline34); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline46); |
| } catch {} |
| try { |
| gpuCanvasContext17.unconfigure(); |
| } catch {} |
| let commandEncoder256 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup4, new Uint32Array(789), 1, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup63); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup1); |
| } catch {} |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout32, veryExplicitBindGroupLayout9]}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer152, 'uint32', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(0, bindGroup61, new Uint32Array(2399), 177, 0); |
| } catch {} |
| try { |
| buffer70.unmap(); |
| } catch {} |
| let img9 = await imageWithData(5, 38, '#10101010', '#20202020'); |
| let sampler40 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat'}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup134); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer118, 'uint32', 520, 225); |
| } catch {} |
| try { |
| commandEncoder222.copyTextureToBuffer({ |
| texture: texture124, |
| mipLevel: 0, |
| origin: {x: 63, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4294 */ |
| offset: 4294, |
| bytesPerRow: 1024, |
| buffer: buffer56, |
| }, {width: 27, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder72.insertDebugMarker('\u0c1e'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer216, 32, new DataView(new ArrayBuffer(68436)), 879, 4); |
| } catch {} |
| let bindGroup143 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout31, |
| entries: [{binding: 58, resource: {buffer: buffer21, size: 1744}}, {binding: 6, resource: {buffer: buffer154}}], |
| }); |
| let textureView289 = texture294.createView({}); |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(3, bindGroup14, new Uint32Array(2453), 708, 1); |
| } catch {} |
| try { |
| await promise35; |
| } catch {} |
| try { |
| computePassEncoder29.setBindGroup(3, bindGroup10, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline5); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer176, 'uint32', 0, 0); |
| } catch {} |
| try { |
| buffer68.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer201, 108, new DataView(new Uint8Array(4482).map((_, i) => i).buffer), 1517, 24); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise36; |
| } catch {} |
| let commandEncoder257 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder5.setVertexBuffer(3, buffer106); |
| } catch {} |
| let imageData38 = new ImageData(44, 20); |
| try { |
| computePassEncoder3.setPipeline(pipeline44); |
| } catch {} |
| try { |
| commandEncoder186.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 48 */ |
| offset: 48, |
| bytesPerRow: 42496, |
| buffer: buffer213, |
| }, { |
| texture: texture170, |
| mipLevel: 0, |
| origin: {x: 50, y: 30, z: 0}, |
| aspect: 'all', |
| }, {width: 50, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer222 = device0.createBuffer({ |
| size: 104, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup139, new Uint32Array(595), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup109, []); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup89, new Uint32Array(2809), 449, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer217); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup134); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(234).fill(33), /* required buffer size: 234 */ |
| {offset: 234}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer223 = device0.createBuffer({size: 124, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let textureView290 = texture287.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup75, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(7, buffer136, 12, 32); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup126, new Uint32Array(797), 48, 0); |
| } catch {} |
| try { |
| commandEncoder84.copyTextureToTexture({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 6, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture202, |
| mipLevel: 0, |
| origin: {x: 612, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 120, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(215).fill(190), /* required buffer size: 215 */ |
| {offset: 215, bytesPerRow: 39}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline54 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x11450e1}, |
| fragment: { |
| module: shaderModule11, |
| entryPoint: 'fragment9', |
| constants: {}, |
| targets: [{ |
| format: 'r16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule10, |
| entryPoint: 'vertex10', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 8, |
| attributes: [ |
| {format: 'sint8x2', offset: 0, shaderLocation: 6}, |
| {format: 'float32', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 2}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint32', offset: 0, shaderLocation: 3}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let commandEncoder258 = device0.createCommandEncoder({}); |
| let querySet4 = device0.createQuerySet({type: 'timestamp', count: 1096}); |
| let texture304 = device0.createTexture({ |
| size: [195, 120, 1], |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup138, [0, 0]); |
| } catch {} |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup25, new Uint32Array(1510), 16, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer9, 'uint32', 40, 23); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline31); |
| } catch {} |
| try { |
| commandEncoder248.resolveQuerySet(querySet2, 31, 0, buffer50, 0); |
| } catch {} |
| try { |
| commandEncoder205.insertDebugMarker('\u{1fcba}'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 0, y: 15, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(282).fill(150), /* required buffer size: 282 */ |
| {offset: 282, bytesPerRow: 26, rowsPerImage: 107}, {width: 0, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img5); |
| let textureView291 = texture32.createView({dimension: '1d', arrayLayerCount: 1}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup119); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline46); |
| } catch {} |
| try { |
| commandEncoder133.copyBufferToBuffer(buffer214, 132, buffer64, 28, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 0, new Uint32Array(3101).map((_, i) => i * 3), 187, 0); |
| } catch {} |
| let imageData39 = new ImageData(164, 36); |
| let commandEncoder259 = device0.createCommandEncoder({}); |
| let textureView292 = texture212.createView({dimension: 'cube', mipLevelCount: 1}); |
| let texture305 = device0.createTexture({ |
| size: [8, 12, 2], |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer106, 'uint32', 68, 9); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup52); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer103, 16, new DataView(new ArrayBuffer(69644)), 582, 68); |
| } catch {} |
| let pipeline55 = device0.createRenderPipeline({ |
| label: '\u53b8\u0326\uc956\u0de7\u0792', |
| layout: 'auto', |
| multisample: {count: 4}, |
| fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint'}]}, |
| vertex: {module: shaderModule11, constants: {}, buffers: []}, |
| primitive: {unclippedDepth: true}, |
| }); |
| try { |
| globalThis.someLabel = externalTexture28.label; |
| } catch {} |
| let bindGroup144 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 6, resource: textureView175}, |
| {binding: 290, resource: {buffer: buffer22}}, |
| {binding: 10, resource: textureView20}, |
| {binding: 711, resource: sampler33}, |
| {binding: 556, resource: textureView124}, |
| {binding: 241, resource: {buffer: buffer34, offset: 0}}, |
| {binding: 3, resource: sampler25}, |
| {binding: 348, resource: {buffer: buffer5}}, |
| {binding: 47, resource: textureView233}, |
| {binding: 7, resource: {buffer: buffer116}}, |
| ], |
| }); |
| try { |
| renderPassEncoder28.setVertexBuffer(5, buffer156, 0); |
| } catch {} |
| let videoFrame40 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'hlg'} }); |
| let textureView293 = texture214.createView({mipLevelCount: 1}); |
| let texture306 = device0.createTexture({ |
| size: [195, 12, 1], |
| mipLevelCount: 5, |
| sampleCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler41 = device0.createSampler({ |
| label: '\u062a\u0f92\ud455\u{1fce1}\u08d9\u{1f9ab}\u8f1d', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.78, |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup97); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup22, new Uint32Array(2517), 47, 1); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(0, bindGroup45); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline41); |
| } catch {} |
| try { |
| buffer51.unmap(); |
| } catch {} |
| try { |
| commandEncoder190.resolveQuerySet(querySet4, 315, 7, buffer190, 0); |
| } catch {} |
| let shaderModule14 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| enable f16; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T2 { |
| f0: array<vec4f>, |
| } |
| |
| struct T1 { |
| f0: array<vec4h>, |
| } |
| |
| var<private> vp15: array<vec4h, 24> = array(vec4h(11110.3, 5864.9, 13455.5, 17012.2), vec4h(2714.6, 5129.0, -64.68, 909.2), vec4h(13694.8, 15867.7, 14773.2, 8468.8), vec4h(11239.1, 4745.5, 14561.3, 7095.6), vec4h(16554.1, 7870.4, 2224.1, -6156.2), vec4h(539.3, 4388.5, 5527.8, -2903.2), vec4h(27715.4, -6159.6, 1951.2, -1896.4), vec4h(8403.9, 10298.0, 6352.0, -6974.1), vec4h(873.9, 22279.5, 1554.6, -4354.3), vec4h(13654.3, 5983.3, 1547.5, 9776.6), vec4h(2733.8, 590.1, 8425.1, 6168.0), vec4h(241.1, 1861.6, -474.9, 7086.7), vec4h(1958.3, 9897.2, 4659.5, 14423.2), vec4h(6403.2, 20983.7, -17369.9, 15420.6), vec4h(5108.4, 4213.7, 13205.7, 4332.0), vec4h(17881.4, 259.8, -2702.7, -1117.7), vec4h(16605.1, -245.5, 9235.9, 1874.1), vec4h(1967.4, 6476.2, 19497.5, 1752.9), vec4h(-29306.0, 3793.2, 6680.9, 7457.0), vec4h(9265.1, 13366.9, 65500.0, -17444.2), vec4h(7803.4, 2001.7, 12006.9, 8672.7), vec4h(697.8, 8364.7, 10078.9, 1493.9), vec4h(8042.8, 13016.5, 2498.5, 4374.3), vec4h(-7732.6, 10953.6, -13021.6, 433.3)); |
| |
| var<private> vp17 = frexp(f16(26140.6)); |
| |
| var<workgroup> vw15: array<array<vec2u, 27>, 1>; |
| |
| @group(2) @binding(138) var st22: texture_storage_2d<r32uint, read_write>; |
| |
| @group(1) @binding(10) var<storage, read> buffer228: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, 1>, 5>, 2>>; |
| |
| struct FragmentInput30 { |
| @location(2) location_2: u32, |
| } |
| |
| @group(1) @binding(141) var sam7: sampler_comparison; |
| |
| var<workgroup> vw14: vec4u; |
| |
| @group(0) @binding(3) var tex15: texture_depth_2d; |
| |
| struct FragmentOutput8 { |
| @location(0) location_0: vec4i, |
| @location(4) location_4: vec4i, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T0 { |
| @size(104) f0: array<array<vec4i, 1>, 1>, |
| } |
| |
| @group(1) @binding(3) var<storage, read_write> buffer226: array<array<array<array<VertexInput51, 206>, 1>, 4>>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp18: u32 = u32(585670675); |
| |
| @group(0) @binding(43) var<uniform> buffer225: array<array<vec4u, 1>, 1>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentInput31 { |
| @location(11) @interpolate(flat, sample) location_11: i32, |
| @location(14) location_14: vec4i, |
| @location(13) location_13: u32, |
| @location(3) location_3: vec4u, |
| @location(10) @interpolate(flat) location_10: vec4u, |
| @location(4) @interpolate(flat, center) location_4: vec2i, |
| @location(0) location_0: vec4i, |
| @location(8) location_8: f32, |
| @location(6) @interpolate(flat, center) location_6: vec4h, |
| @location(1) location_1: f32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct FragmentInput32 { |
| @builtin(sample_mask) sample_mask: u32, |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| var<private> vp14 = modf(f16(6002.5)); |
| |
| @group(0) @binding(6) var<storage, read_write> buffer224: T2; |
| |
| @group(1) @binding(5) var<storage, read> buffer227: array<ComputeInput16>; |
| |
| var<private> vp16: u32 = u32(342984358); |
| |
| struct VertexInput51 { |
| @location(4) @interpolate(flat, either) location_4: u32, |
| @location(11) location_11: f16, |
| } |
| |
| @group(2) @binding(1) var et17: texture_external; |
| |
| struct ComputeInput17 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| /* used global variables: tex15 */ |
| fn fn1(a0: ptr<private, vec4h>, a1: array<f16, 1>, a2: ptr<function, vec4<bool>>, a3: ptr<function, vec4<bool>>, a4: ptr<function, mat4x4h>, a5: vec2f, a6: ptr<private, u32>, a7: ptr<uniform, vec4u>, a8: texture_storage_3d<rgba8sint, read>, a9: ptr<private, i32>, a10: ptr<uniform, array<array<vec4u, 1>, 1>>, a11: ptr<private, f16>, a12: ptr<uniform, vec4u>, a13: ptr<uniform, vec4u>, a14: vec2h, a15: array<f32, 1>, a16: texture_depth_2d, a17: bool, a18: ptr<private, array<vec4h, 24>>, a19: array<array<array<vec2i, 1>, 1>, 2>, a20: texture_external, a21: vec4h, a22: ptr<uniform, array<array<vec4u, 1>, 1>>, a23: array<vec4f, 1>, a24: vec2u, a25: f16, a26: i32, a27: vec2u, a28: array<array<vec4<bool>, 1>, 1>, a29: ptr<private, i32>, a30: ptr<private, f16>, a31: texture_depth_2d, a32: array<array<array<vec2i, 1>, 6>, 1>, a33: ptr<private, u32>, a34: mat3x4h, a35: ptr<function, array<f16, 15>>, a36: ptr<private, u32>, a37: array<f32, 9>, a38: i32, a39: ptr<private, f16>, a40: vec2u, a41: vec4h, a42: vec4i, a43: ptr<private, f16>, a44: array<vec4f, 1>, a45: ptr<private, vec4h>, a46: ptr<private, i32>, a47: ptr<uniform, array<array<vec4u, 1>, 1>>, a48: ptr<function, array<array<array<f32, 1>, 1>, 44>>, a49: texture_external, a50: array<array<vec2i, 1>, 1>, a51: vec4h, a52: array<array<bool, 1>, 1>, a53: bool, a54: ptr<uniform, vec4u>, a55: array<array<array<array<array<array<vec2h, 2>, 1>, 1>, 1>, 1>, 1>, a56: ptr<uniform, vec4u>, a57: ptr<uniform, vec4u>, a58: array<vec2<bool>, 1>, a59: array<array<vec2f, 14>, 1>, a60: array<array<u32, 1>, 1>, a61: ptr<private, f16>, a62: ptr<private, u32>, a63: ptr<private, i32>, a64: ptr<private, u32>, a65: ptr<function, vec4u>, a66: ptr<private, array<vec4h, 24>>, a67: vec2i, a68: array<vec4i, 1>, a69: ptr<private, array<vec4h, 24>>, a70: texture_storage_3d<rgba8sint, read>, a71: ptr<private, u32>, a72: array<array<vec2i, 1>, 1>, a73: ptr<uniform, vec4u>, a74: array<array<array<array<array<i32, 1>, 4>, 1>, 1>, 9>, a75: ptr<function, array<vec4f, 1>>, a76: texture_depth_2d, a77: vec2h, a78: ptr<private, i32>, a79: texture_storage_3d<rgba8sint, read>, a80: f16, a81: texture_depth_2d, a82: ptr<private, u32>, a83: texture_depth_2d, a84: array<u32, 1>, a85: f32, a86: texture_external, a87: ptr<uniform, array<vec4u, 1>>, a88: ptr<private, f16>) { |
| (*a33) |= bitcast<u32>(a55[0][0][unconst_u32(69151054)][unconst_u32(1125559499)][unconst_u32(381548131)][u32((*a18)[23][1])]); |
| let ptr96: ptr<uniform, vec4u> = &(*a22)[0][0]; |
| let vf146: u32 = textureNumLevels(a31); |
| var vf147: vec2u = textureDimensions(a31, unconst_i32(117227048)); |
| let vf148: vec2h = a55[bitcast<u32>(textureLoad(tex15, vec2i(unconst_i32(54304836), unconst_i32(627216151)), unconst_i32(955242402)))][unconst_u32(1527567358)][0][unconst_u32(2347414637)][0][1]; |
| _ = tex15; |
| } |
| |
| /* used global variables: buffer224, buffer226, buffer227, sam7, st22 */ |
| fn fn0() -> array<array<u32, 2>, 1> { |
| var out: array<array<u32, 2>, 1>; |
| let ptr88: ptr<storage, f16, read_write> = &buffer226[arrayLength(&buffer226)][3][0][unconst_u32(308982695)].location_11; |
| while bool((*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(49056313)][unconst_u32(106085698)][205].location_4) { |
| textureStore(st22, vec2i(unconst_i32(459732689), unconst_i32(604299715)), vec4u(vec4u(unconst_u32(556759929), unconst_u32(2836172100), unconst_u32(751113878), unconst_u32(93316804)))); |
| let ptr89: ptr<storage, VertexInput51, read_write> = &(*&buffer226)[(*&buffer226)[arrayLength(&(*&buffer226))][3][0][205].location_4][3][unconst_u32(1291629345)][unconst_u32(2099615403)]; |
| _ = st22; |
| _ = buffer226; |
| } |
| for (var jj57=0u; jj57<3; jj57++) { out[jj57][1] >>= u32(buffer226[arrayLength(&buffer226)][3][0][205].location_11); } |
| let ptr90: ptr<storage, array<array<VertexInput51, 206>, 1>, read_write> = &buffer226[unconst_u32(118519933)][3]; |
| vp16 |= out[0][1]; |
| for (var jj90=0u; jj90<6; jj90++) { for (var jj5=0u; jj5<3; jj5++) { buffer226[unconst_u32(70639194)][jj90][jj5][unconst_u32(3118629580)].location_4 = u32((*ptr90)[0][unconst_u32(1566681132)].location_11); } } |
| let ptr91: ptr<storage, array<vec4f>, read_write> = &(*&buffer224).f0; |
| let ptr92: ptr<storage, VertexInput51, read_write> = &(*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(476936104)][unconst_u32(51115597)][unconst_u32(1017900059)]; |
| { |
| _ = sam7; |
| vp15[unconst_u32(526922545)] = vec4h(buffer227[arrayLength(&buffer227)].num_workgroups.brgg); |
| let ptr93: ptr<storage, vec3u, read> = &(*&buffer227)[unconst_u32(709737328)].num_workgroups; |
| vp18 = (*&buffer226)[arrayLength(&(*&buffer226))][3][0][205].location_4; |
| let ptr94: ptr<storage, array<array<array<array<VertexInput51, 206>, 1>, 4>>, read_write> = &buffer226; |
| _ = sam7; |
| _ = buffer226; |
| _ = buffer227; |
| } |
| let ptr95: ptr<storage, f16, read_write> = &buffer226[buffer226[unconst_u32(815797275)][unconst_u32(305030721)][0][205].location_4][unconst_u32(787597762)][0][unconst_u32(210007444)].location_11; |
| return out; |
| _ = buffer226; |
| _ = buffer227; |
| _ = sam7; |
| _ = buffer224; |
| _ = st22; |
| } |
| |
| struct VertexOutput11 { |
| @location(0) @interpolate(flat, first) location_0: i32, |
| @location(6) @interpolate(flat, either) location_6: i32, |
| @location(2) @interpolate(flat, first) location_2: vec4u, |
| @location(8) location_8: f16, |
| @location(15) @interpolate(linear, centroid) location_15: vec2h, |
| @location(14) location_14: f16, |
| @location(7) @interpolate(flat, center) location_7: i32, |
| @location(10) @interpolate(perspective, centroid) location_10: f16, |
| @builtin(position) position: vec4f, |
| @location(5) @interpolate(flat, either) location_5: u32, |
| } |
| |
| struct ComputeInput16 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| /* used global variables: buffer225 */ |
| @vertex |
| fn vertex16(@location(8) location_8: i32, @location(7) @interpolate(linear, first) location_7: vec4f, @location(14) location_14: vec4u, a3: VertexInput51, @location(1) location_1: i32, @location(13) location_13: vec2f, @location(15) location_15: vec4f, @location(5) location_5: vec4f) -> VertexOutput11 { |
| var out: VertexOutput11; |
| out.position = vec4f((*&buffer225)[0][0]); |
| out.location_6 ^= i32(location_7[unconst_u32(744215807)]); |
| loop { |
| let ptr97: ptr<private, f16> = &vp17.fract; |
| out.location_7 -= i32(out.location_10); |
| out.location_10 = vec4h(out.location_2.bgrr.ggaa.yyxw).w; |
| break; |
| } |
| out.location_15 = bitcast<vec2h>(out.position[unconst_u32(389805323)]); |
| return out; |
| _ = buffer225; |
| } |
| |
| /* used global variables: buffer224, buffer226, buffer227, et17, sam7, st22 */ |
| @fragment |
| fn fragment13(@location(9) @interpolate(flat) location_9: vec4i, @location(5) location_5: f16, a2: FragmentInput30, a3: FragmentInput31, a4: FragmentInput32, @builtin(front_facing) front_facing: bool, @builtin(position) position: vec4f) -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| vp16 = u32(buffer226[unconst_u32(105259827)][unconst_u32(553888791)][0][205].location_11); |
| _ = fn0(); |
| _ = fn0(); |
| while bool(pack4xU8Clamp(a3.location_3)) { |
| let ptr98: ptr<storage, u32, read_write> = &(*&buffer226)[unconst_u32(1529970243)][3][0][unconst_u32(934382657)].location_4; |
| _ = buffer226; |
| } |
| for (var ii95=0u; ii95<0x1000; ii95+=0x11) { buffer226[ii95][unconst_u32(165485834)][unconst_u32(325608794)][unconst_u32(36297055)] = VertexInput51(u32(buffer226[unconst_u32(314606921)][3][0][205].location_11), buffer226[unconst_u32(314606921)][3][0][205].location_11); } |
| switch i32((*&buffer226)[unconst_u32(1088022223)][3][0][u32((*&buffer224).f0[arrayLength(&(*&buffer224).f0)][unconst_u32(444830667)])].location_4) { |
| default { |
| fn0(); |
| while bool(vp15[23][0]) { |
| vp16 = textureDimensions(et17)[1]; |
| { |
| discard; |
| break; |
| } |
| let ptr99: ptr<storage, VertexInput51, read_write> = &buffer226[unconst_u32(806324667)][unconst_u32(494345405)][0][unconst_u32(493366067)]; |
| var vf149: f32 = a3.location_8; |
| _ = et17; |
| _ = buffer226; |
| } |
| buffer224 = buffer224; |
| let ptr100: ptr<storage, f16, read_write> = &buffer226[u32((*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(1056256282)][0][205].location_11)][unconst_u32(208338565)][unconst_u32(123324928)][205].location_11; |
| let ptr101: ptr<function, vec4i> = &out.location_0; |
| return out; |
| _ = buffer226; |
| _ = buffer227; |
| _ = et17; |
| _ = st22; |
| _ = sam7; |
| _ = buffer224; |
| } |
| } |
| fn0(); |
| let ptr102: ptr<storage, f16, read_write> = &buffer226[u32(buffer226[unconst_u32(115120913)][unconst_u32(390566168)][0][unconst_u32(586965775)].location_11)][unconst_u32(140938035)][0][205].location_11; |
| vp15[unconst_u32(584859340)] = vec4h(buffer226[arrayLength(&buffer226)][3][0][unconst_u32(311153750)].location_11); |
| discard; |
| return out; |
| _ = buffer224; |
| _ = st22; |
| _ = buffer227; |
| _ = buffer226; |
| _ = et17; |
| _ = sam7; |
| } |
| |
| /* used global variables: buffer224, buffer226, buffer228 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute13(a0: ComputeInput16, @builtin(workgroup_id) workgroup_id: vec3u, a2: ComputeInput17) { |
| let ptr103: ptr<storage, array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, read> = &(*&buffer228)[unconst_u32(471229779)][1][4][unconst_u32(84102593)]; |
| vp15[unconst_u32(114219066)] -= vec4h((*&buffer228)[arrayLength(&(*&buffer228))][1][4][0][0][unconst_u32(640083672)][unconst_u32(1745620298)][0][0]); |
| let ptr104: ptr<storage, array<array<array<f16, 1>, 1>, 1>, read> = &(*&buffer228)[arrayLength(&(*&buffer228))][u32(buffer228[arrayLength(&buffer228)][1][unconst_u32(120749647)][unconst_u32(2043054)][0][2][0][0][0])][unconst_u32(120773386)][unconst_u32(276637954)][0][2]; |
| vp18 >>= u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(188534844)][4][0][0][2][unconst_u32(479685927)][unconst_u32(900034271)][unconst_u32(1011933467)]); |
| vp14.whole = f16(buffer224.f0[arrayLength(&buffer224.f0)][unconst_u32(312821784)]); |
| let ptr105: ptr<storage, f16, read> = &buffer228[unconst_u32(659768168)][1][unconst_u32(651813982)][0][0][unconst_u32(133905741)][0][u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(1401646194)][4][unconst_u32(846165652)][0][unconst_u32(98513160)][unconst_u32(352667124)][0][0])][unconst_u32(13615421)]; |
| let ptr106: ptr<storage, array<f16, 1>, read> = &(*ptr103)[unconst_u32(80969995)][unconst_u32(387677913)][unconst_u32(732010015)][unconst_u32(358353197)]; |
| vw15[0][unconst_u32(1072859130)] = vec2u(u32(buffer228[u32((*&buffer228)[unconst_u32(338446310)][unconst_u32(1928796179)][unconst_u32(78324188)][unconst_u32(987792518)][0][unconst_u32(2130222589)][buffer226[unconst_u32(54969414)][3][0][205].location_4][unconst_u32(480912853)][0])][unconst_u32(1289504550)][unconst_u32(1096530562)][unconst_u32(320835443)][u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(149150570)][4][unconst_u32(1255878758)][u32((*ptr103)[0][2][unconst_u32(1546452610)][0][0])][u32((*&buffer228)[unconst_u32(981619654)][unconst_u32(1770794891)][unconst_u32(889724456)][0][(*&buffer226)[arrayLength(&(*&buffer226))][unconst_u32(671842661)][unconst_u32(50295120)][unconst_u32(686215956)].location_4][u32(buffer228[arrayLength(&buffer228)][1][4][0][unconst_u32(1155235854)][2][0][0][0])][0][u32(buffer228[arrayLength(&buffer228)][unconst_u32(133748179)][unconst_u32(244697320)][0][0][2][unconst_u32(427996051)][0][0])][0])][0][unconst_u32(374451571)][0])][2][unconst_u32(1762659725)][0][0])); |
| let ptr107: ptr<storage, array<f16, 1>, read> = &(*&buffer228)[unconst_u32(220075753)][unconst_u32(9194753)][unconst_u32(4097970172)][unconst_u32(382721671)][0][2][0][0]; |
| vw14 = unpack4xU8(u32((*&buffer228)[arrayLength(&(*&buffer228))][unconst_u32(1391619915)][4][0][unconst_u32(2199505061)][unconst_u32(2130902607)][unconst_u32(195836693)][unconst_u32(289579462)][0])); |
| _ = buffer224; |
| _ = buffer228; |
| _ = buffer226; |
| }`, |
| }); |
| let autogeneratedBindGroupLayout36 = pipeline17.getBindGroupLayout(0); |
| let commandEncoder260 = device0.createCommandEncoder({}); |
| let texture307 = device0.createTexture({ |
| size: [2, 2, 14], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg8sint'], |
| }); |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup82, new Uint32Array(466), 72, 0); |
| } catch {} |
| let bindGroup145 = device0.createBindGroup({layout: autogeneratedBindGroupLayout11, entries: []}); |
| let texture308 = device0.createTexture({ |
| size: {width: 195, height: 120, depthOrArrayLayers: 345}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup55, [256, 0]); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup132); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 120, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 8, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture297, |
| mipLevel: 0, |
| origin: {x: 24, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup57, []); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer179, 60, 3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup3, new Uint32Array(808), 8, 1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(0, buffer143, 0, 9); |
| } catch {} |
| let pipeline56 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, constants: {5_373: 1}}}); |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(40); }; |
| } catch {} |
| let buffer230 = device0.createBuffer({size: 44, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| renderBundleEncoder12.setPipeline(pipeline38); |
| } catch {} |
| try { |
| commandEncoder151.copyTextureToBuffer({ |
| texture: texture161, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 944 */ |
| offset: 944, |
| rowsPerImage: 1160, |
| buffer: buffer187, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 75, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 92, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 197, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 234, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 992, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup146 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 3, resource: textureView0}, |
| {binding: 43, resource: {buffer: buffer186, size: 115}}, |
| {binding: 6, resource: {buffer: buffer204, offset: 0, size: 16}}, |
| {binding: 58, resource: {buffer: buffer116}}, |
| ], |
| }); |
| let texture309 = device0.createTexture({ |
| size: {width: 780, height: 48, depthOrArrayLayers: 54}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView294 = texture97.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup32, new Uint32Array(7256), 1_027, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup36, new Uint32Array(2791), 16, 1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(1, buffer68, 32); |
| } catch {} |
| let commandEncoder261 = device0.createCommandEncoder({}); |
| let textureView295 = texture66.createView({format: 'r16sint'}); |
| let externalTexture55 = device0.importExternalTexture({source: videoFrame27}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup101, new Uint32Array(366), 154, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup82, new Uint32Array(679), 25, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer65, 'uint16', 12, 0); |
| } catch {} |
| try { |
| texture29.destroy(); |
| } catch {} |
| try { |
| buffer191.unmap(); |
| } catch {} |
| try { |
| commandEncoder236.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext14.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 97, height: 60, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData34, |
| origin: { x: 3, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 18, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise37 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x5dc12f4f}, |
| fragment: { |
| module: shaderModule11, |
| entryPoint: 'fragment9', |
| constants: {}, |
| targets: [{ |
| format: 'r16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex2', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 36, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32x3', offset: 0, shaderLocation: 14}, {format: 'uint32', offset: 0, shaderLocation: 2}], |
| }, |
| { |
| arrayStride: 40, |
| stepMode: 'vertex', |
| attributes: [{format: 'float32x2', offset: 0, shaderLocation: 6}], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw'}, |
| }); |
| let bindGroup147 = device0.createBindGroup({ |
| label: '\uf723\u7c19\ud6a0\ua3ee\uf353\u05c3\u3d50\u29bf\u0fdd\u{1f9a1}', |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 7, resource: externalTexture2}, |
| {binding: 3, resource: {buffer: buffer22}}, |
| {binding: 14, resource: {buffer: buffer116}}, |
| {binding: 11, resource: {buffer: buffer110, offset: 0}}, |
| {binding: 33, resource: textureView58}, |
| {binding: 212, resource: textureView29}, |
| {binding: 1, resource: textureView201}, |
| {binding: 39, resource: textureView0}, |
| ], |
| }); |
| let texture310 = device0.createTexture({size: {width: 390}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderBundleEncoder23.setVertexBuffer(0, buffer128, 0); |
| } catch {} |
| try { |
| commandEncoder74.copyTextureToTexture({ |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 310, y: 13, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 72, y: 17, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 354, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder262 = device0.createCommandEncoder(); |
| let texture311 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer63, 'uint32', 312, 31); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer172, 'uint32', 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline48); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer91, 2_608, new Uint32Array(3470).map((_, i) => i * 4), 102, 504); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup148 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout12, |
| entries: [{binding: 6, resource: {buffer: buffer136}}, {binding: 58, resource: {buffer: buffer37}}], |
| }); |
| let texture312 = device0.createTexture({ |
| size: [390, 24, 1], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture313 = device0.createTexture({size: [2, 2, 23], dimension: '3d', format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderBundleEncoder9.setVertexBuffer(1, buffer172, 0, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer189, 4, new Float64Array(22343).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/22339)), 1141, 0); |
| } catch {} |
| let pipeline57 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}}); |
| let bindGroup149 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout17, |
| entries: [ |
| {binding: 48, resource: textureView17}, |
| {binding: 0, resource: {buffer: buffer107}}, |
| {binding: 32, resource: externalTexture52}, |
| {binding: 1, resource: sampler36}, |
| {binding: 365, resource: textureView170}, |
| {binding: 5, resource: sampler23}, |
| {binding: 184, resource: {buffer: buffer32}}, |
| ], |
| }); |
| let buffer231 = device0.createBuffer({size: 92, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder263 = device0.createCommandEncoder({}); |
| let textureView296 = texture312.createView({format: 'rgba8snorm', mipLevelCount: 1}); |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup82, new Uint32Array(964), 133, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer199, 'uint16', 14, 23); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(0, buffer137, 0, 2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder222.resolveQuerySet(querySet3, 23, 0, buffer109, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer179, 24, new Uint16Array(38531).map((_, i) => i + 7), 3333, 4); |
| } catch {} |
| let bindGroup150 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout26, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer82}}, |
| {binding: 6, resource: {buffer: buffer103}}, |
| {binding: 58, resource: {buffer: buffer37}}, |
| ], |
| }); |
| let texture314 = device0.createTexture({ |
| size: [390, 240, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView297 = texture114.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let externalTexture56 = device0.importExternalTexture({source: videoFrame36}); |
| try { |
| renderPassEncoder30.setVertexBuffer(3, buffer118, 0, 1_353); |
| } catch {} |
| try { |
| renderBundleEncoder20.insertDebugMarker('\u6a41'); |
| } catch {} |
| let commandEncoder264 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer131, 'uint32', 64, 72); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer65, 'uint32', 0, 13); |
| } catch {} |
| try { |
| commandEncoder250.insertDebugMarker('\u7343'); |
| } catch {} |
| try { |
| computePassEncoder17.insertDebugMarker('\u04a4'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer136, 32, new DataView(new ArrayBuffer(32388)), 975, 0); |
| } catch {} |
| let bindGroup151 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 84, resource: {buffer: buffer21, size: 1292}}, |
| {binding: 201, resource: {buffer: buffer37}}, |
| {binding: 219, resource: textureView17}, |
| {binding: 45, resource: externalTexture33}, |
| {binding: 284, resource: textureView262}, |
| {binding: 211, resource: {buffer: buffer179}}, |
| {binding: 386, resource: textureView7}, |
| {binding: 117, resource: {buffer: buffer107}}, |
| {binding: 40, resource: externalTexture9}, |
| {binding: 264, resource: textureView36}, |
| {binding: 0, resource: {buffer: buffer36, size: 49}}, |
| {binding: 255, resource: {buffer: buffer21, size: 912}}, |
| {binding: 210, resource: {buffer: buffer21, offset: 0, size: 1768}}, |
| {binding: 33, resource: textureView250}, |
| {binding: 2, resource: {buffer: buffer120}}, |
| {binding: 9, resource: {buffer: buffer34}}, |
| {binding: 269, resource: textureView28}, |
| {binding: 11, resource: {buffer: buffer21, size: 3108}}, |
| {binding: 6, resource: textureView213}, |
| {binding: 5, resource: textureView260}, |
| {binding: 7, resource: textureView4}, |
| {binding: 3, resource: {buffer: buffer21, size: 448}}, |
| {binding: 148, resource: textureView36}, |
| ], |
| }); |
| let texture315 = device0.createTexture({ |
| size: {width: 780}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup19, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup72, new Uint32Array(1728), 78, 0); |
| } catch {} |
| let bindGroup152 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer174}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 58, resource: {buffer: buffer116}}, |
| {binding: 6, resource: {buffer: buffer154}}, |
| ], |
| }); |
| let textureView298 = texture300.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer112, 'uint32', 52, 58); |
| } catch {} |
| let commandEncoder265 = device0.createCommandEncoder(); |
| let textureView299 = texture53.createView({}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup34, [0]); |
| } catch {} |
| try { |
| gpuCanvasContext17.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer130, 0, new Float32Array(12157).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.1379)), 2270, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 195, height: 120, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData39, |
| origin: { x: 0, y: 9 }, |
| flipY: false, |
| }, { |
| texture: texture297, |
| mipLevel: 0, |
| origin: {x: 3, y: 20, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData40 = new ImageData(4, 12); |
| let bindGroup153 = device0.createBindGroup({layout: autogeneratedBindGroupLayout20, entries: [{binding: 1, resource: externalTexture38}]}); |
| let commandEncoder266 = device0.createCommandEncoder({}); |
| try { |
| buffer139.unmap(); |
| } catch {} |
| let commandEncoder267 = device0.createCommandEncoder(); |
| let texture316 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 14}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| commandEncoder264.copyTextureToBuffer({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 304 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1536 */ |
| offset: 1536, |
| rowsPerImage: 2998, |
| buffer: buffer56, |
| }, {width: 114, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup154 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 15, resource: {buffer: buffer70}}, |
| {binding: 152, resource: textureView87}, |
| {binding: 141, resource: {buffer: buffer157, size: 48}}, |
| {binding: 166, resource: textureView88}, |
| {binding: 148, resource: {buffer: buffer43}}, |
| {binding: 125, resource: textureView270}, |
| {binding: 81, resource: externalTexture55}, |
| {binding: 2, resource: textureView100}, |
| {binding: 86, resource: {buffer: buffer116}}, |
| {binding: 220, resource: {buffer: buffer141}}, |
| {binding: 11, resource: textureView26}, |
| {binding: 3, resource: textureView134}, |
| {binding: 106, resource: {buffer: buffer107}}, |
| {binding: 4, resource: {buffer: buffer153, offset: 0}}, |
| {binding: 1, resource: externalTexture51}, |
| {binding: 251, resource: {buffer: buffer81, size: 28}}, |
| {binding: 6, resource: textureView3}, |
| {binding: 5, resource: {buffer: buffer209}}, |
| {binding: 12, resource: textureView251}, |
| {binding: 0, resource: {buffer: buffer21, offset: 256, size: 1288}}, |
| ], |
| }); |
| let textureView300 = texture312.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup16, new Uint32Array(2572), 133, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let textureView301 = texture290.createView({}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup153, new Uint32Array(717), 68, 0); |
| } catch {} |
| let imageData41 = new ImageData(36, 16); |
| try { |
| renderPassEncoder26.executeBundles([renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(3, buffer160); |
| } catch {} |
| let bindGroup155 = device0.createBindGroup({layout: autogeneratedBindGroupLayout19, entries: []}); |
| let texture317 = device0.createTexture({ |
| size: {width: 8, height: 12, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(2, buffer160, 0); |
| } catch {} |
| try { |
| commandEncoder247.popDebugGroup(); |
| } catch {} |
| let pipeline58 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x425c5ca3}, |
| fragment: {module: shaderModule11, entryPoint: 'fragment9', targets: [{format: 'r16sint'}]}, |
| vertex: { |
| module: shaderModule7, |
| constants: {override18: 1}, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint8x4', offset: 0, shaderLocation: 7}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 8}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 12}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 9}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 14}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 6}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 3}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 5}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4}, |
| {format: 'float32', offset: 0, shaderLocation: 13}, |
| {format: 'uint32', offset: 0, shaderLocation: 11}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup134); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup27, new Uint32Array(885), 146, 1); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(3, bindGroup98, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder28.insertDebugMarker('\u0d42'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 780, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 65, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer232 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let externalTexture57 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle4, renderBundle4, renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer93, 'uint16', 4, 15); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup131); |
| } catch {} |
| try { |
| commandEncoder50.copyBufferToBuffer(buffer103, 44, buffer120, 0, 12); |
| } catch {} |
| try { |
| gpuCanvasContext15.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer64, 124, new Float64Array(2896).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/2891)), 542, 0); |
| } catch {} |
| offscreenCanvas7.width = 38; |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup138, [0, 0]); |
| } catch {} |
| try { |
| commandEncoder131.copyTextureToTexture({ |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 132, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline59 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, constants: {}, targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALPHA}]}, |
| vertex: {module: shaderModule12, buffers: []}, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let textureView302 = texture309.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder29.setPipeline(pipeline50); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer172, 'uint32', 4, 5); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer120, 'uint16', 50, 7); |
| } catch {} |
| try { |
| commandEncoder132.copyTextureToTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 5}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 53, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer138, 40, new Float32Array(7848).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.07350)), 2257, 0); |
| } catch {} |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup67, new Uint32Array(255), 10, 0); |
| } catch {} |
| try { |
| commandEncoder98.resolveQuerySet(querySet3, 107, 0, buffer230, 0); |
| } catch {} |
| let imageData42 = new ImageData(36, 72); |
| let bindGroup156 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer90, size: 66}}, |
| {binding: 386, resource: textureView17}, |
| {binding: 84, resource: {buffer: buffer116}}, |
| {binding: 201, resource: {buffer: buffer21, size: 1288}}, |
| {binding: 210, resource: {buffer: buffer107}}, |
| {binding: 284, resource: textureView59}, |
| {binding: 3, resource: {buffer: buffer136}}, |
| {binding: 211, resource: {buffer: buffer51}}, |
| {binding: 5, resource: textureView282}, |
| {binding: 40, resource: externalTexture8}, |
| {binding: 6, resource: textureView220}, |
| {binding: 219, resource: textureView3}, |
| {binding: 148, resource: textureView243}, |
| {binding: 255, resource: {buffer: buffer37}}, |
| {binding: 11, resource: {buffer: buffer21, size: 3156}}, |
| {binding: 9, resource: {buffer: buffer205}}, |
| {binding: 45, resource: externalTexture14}, |
| {binding: 117, resource: {buffer: buffer21, size: 1524}}, |
| {binding: 264, resource: textureView54}, |
| {binding: 269, resource: textureView160}, |
| {binding: 2, resource: {buffer: buffer158}}, |
| {binding: 33, resource: textureView239}, |
| {binding: 7, resource: textureView278}, |
| ], |
| }); |
| let buffer233 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST}); |
| let texture318 = device0.createTexture({ |
| size: [97, 60, 35], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView303 = texture304.createView({dimension: '2d-array'}); |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer100, 'uint16', 80, 23); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline60 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute1'}}); |
| document.body.prepend(img1); |
| let bindGroup157 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 269, resource: textureView284}, |
| {binding: 2, resource: {buffer: buffer80}}, |
| {binding: 45, resource: externalTexture14}, |
| {binding: 9, resource: {buffer: buffer20}}, |
| {binding: 284, resource: textureView285}, |
| {binding: 219, resource: textureView0}, |
| {binding: 264, resource: textureView36}, |
| {binding: 0, resource: {buffer: buffer54, size: 48}}, |
| {binding: 6, resource: textureView32}, |
| {binding: 3, resource: {buffer: buffer190}}, |
| {binding: 7, resource: textureView278}, |
| {binding: 386, resource: textureView17}, |
| {binding: 255, resource: {buffer: buffer116, offset: 0}}, |
| {binding: 84, resource: {buffer: buffer21, size: 1660}}, |
| {binding: 11, resource: {buffer: buffer21, size: 3124}}, |
| {binding: 5, resource: textureView17}, |
| {binding: 210, resource: {buffer: buffer21, size: 1532}}, |
| {binding: 40, resource: externalTexture3}, |
| {binding: 211, resource: {buffer: buffer37}}, |
| {binding: 33, resource: textureView241}, |
| {binding: 201, resource: {buffer: buffer107, offset: 256}}, |
| {binding: 148, resource: textureView54}, |
| {binding: 117, resource: {buffer: buffer21, size: 1556}}, |
| ], |
| }); |
| let textureView304 = texture45.createView({dimension: 'cube', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup12, new Uint32Array(1101), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(5, buffer185, 0, 219); |
| } catch {} |
| let buffer234 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let textureView305 = texture300.createView({mipLevelCount: 1}); |
| try { |
| commandEncoder205.copyTextureToTexture({ |
| texture: texture216, |
| mipLevel: 1, |
| origin: {x: 170, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture302, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer141, 20, new Float16Array(7854).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.583)), 1053, 4); |
| } catch {} |
| let bindGroup158 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [{binding: 69, resource: textureView174}, {binding: 14, resource: textureView223}], |
| }); |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer38, 'uint16', 4, 7); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet3, 10, 24, buffer96, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer132, 12, new Float32Array(7905).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9544)), 2836, 16); |
| } catch {} |
| let autogeneratedBindGroupLayout37 = pipeline49.getBindGroupLayout(0); |
| let texture319 = device0.createTexture({ |
| size: {width: 780, height: 480, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView306 = texture290.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup83, new Uint32Array(3129), 146, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer193, 0, 11); |
| } catch {} |
| try { |
| await shaderModule9.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder81.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 726 */ |
| offset: 726, |
| bytesPerRow: 13056, |
| buffer: buffer11, |
| }, { |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup159 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout29, |
| entries: [{binding: 58, resource: {buffer: buffer116, offset: 0}}], |
| }); |
| let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup144, new Uint32Array(2319), 297, 1); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup38, new Uint32Array(1558), 188, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer53, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline40); |
| } catch {} |
| try { |
| commandEncoder265.copyTextureToBuffer({ |
| texture: texture203, |
| mipLevel: 0, |
| origin: {x: 10, y: 50, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 192 */ |
| offset: 192, |
| bytesPerRow: 25600, |
| buffer: buffer200, |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame41 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'film', transfer: 'smpte240m'} }); |
| let bindGroup160 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout25, |
| entries: [ |
| {binding: 43, resource: textureView118}, |
| {binding: 234, resource: externalTexture7}, |
| {binding: 3, resource: textureView65}, |
| {binding: 1, resource: textureView169}, |
| {binding: 92, resource: sampler0}, |
| {binding: 197, resource: textureView0}, |
| {binding: 75, resource: textureView304}, |
| {binding: 992, resource: {buffer: buffer56}}, |
| ], |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup134, new Uint32Array(903), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer112, 'uint32', 24, 9); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline39); |
| } catch {} |
| let texture320 = gpuCanvasContext14.getCurrentTexture(); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup148, []); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(2, buffer156); |
| } catch {} |
| try { |
| computePassEncoder14.pushDebugGroup('\u09ce'); |
| } catch {} |
| try { |
| computePassEncoder14.popDebugGroup(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| await gc(); |
| let textureView307 = texture103.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup132, new Uint32Array(637), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.beginOcclusionQuery(193); |
| } catch {} |
| let offscreenCanvas9 = new OffscreenCanvas(565, 111); |
| let videoFrame42 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'iec6196624'} }); |
| let textureView308 = texture190.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder27.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer100, 'uint32', 12, 141); |
| } catch {} |
| try { |
| computePassEncoder15.insertDebugMarker('\u0b55'); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup25, [0]); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(5, buffer118, 0, 1_475); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup152, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(7, buffer190, 0, 48); |
| } catch {} |
| try { |
| commandEncoder124.copyTextureToBuffer({ |
| texture: texture164, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 198 */ |
| offset: 198, |
| buffer: buffer221, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder152.clearBuffer(buffer201); |
| } catch {} |
| let videoFrame43 = videoFrame9.clone(); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup62); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(3, bindGroup131); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(19); }; |
| } catch {} |
| document.body.append(canvas6); |
| let bindGroup161 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 557, resource: externalTexture41}, |
| {binding: 0, resource: {buffer: buffer205, size: 20}}, |
| {binding: 176, resource: {buffer: buffer107}}, |
| ], |
| }); |
| let buffer235 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup23, new Uint32Array(2878), 279, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer188, 'uint16', 68, 90); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(1, buffer185, 0, 1_921); |
| } catch {} |
| try { |
| buffer200.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(2); }; |
| } catch {} |
| let texture321 = device0.createTexture({ |
| size: {width: 97, height: 60, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView309 = texture25.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup94, new Uint32Array(5521), 1_397, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 97, height: 60, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 19, y: 88 }, |
| flipY: false, |
| }, { |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 20, y: 28, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer236 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_DST}); |
| let computePassEncoder31 = commandEncoder102.beginComputePass(); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup134); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline52); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup84, new Uint32Array(1145), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer188, 'uint32', 108, 89); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup120, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder16.insertDebugMarker('\u{1f934}'); |
| } catch {} |
| try { |
| gpuCanvasContext14.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer233, 0, new Float32Array(24944).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.2011)), 7295, 4); |
| } catch {} |
| document.body.prepend(img5); |
| let texture322 = device0.createTexture({size: [8, 12, 28], format: 'r16sint', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup45, new Uint32Array(680), 383, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer217, 0, 9); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup68, new Uint32Array(2960), 264, 0); |
| } catch {} |
| let arrayBuffer13 = buffer173.getMappedRange(0, 4); |
| let promise38 = device0.queue.onSubmittedWorkDone(); |
| let buffer237 = device0.createBuffer({size: 122, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer118, 'uint32', 1_044, 240); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(4, buffer186, 36); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer223.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let texture323 = device0.createTexture({ |
| size: [8, 12, 2], |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup86); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer172, 4); |
| } catch {} |
| try { |
| renderBundleEncoder28.pushDebugGroup('\u4226'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer138, 4, new Float32Array(21640).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6422)), 7130, 12); |
| } catch {} |
| document.body.append(img6); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup104); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer108, 'uint16', 0, 0); |
| } catch {} |
| try { |
| await promise38; |
| } catch {} |
| let texture324 = device0.createTexture({ |
| size: {width: 780}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView310 = texture227.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup22, new Uint32Array(353), 12, 1); |
| } catch {} |
| try { |
| renderPassEncoder28.beginOcclusionQuery(668); |
| } catch {} |
| try { |
| renderPassEncoder20.setBlendConstant({ r: 100.9, g: -830.1, b: -521.3, a: -748.3, }); |
| } catch {} |
| try { |
| renderPassEncoder31.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer137, 'uint32', 4, 4); |
| } catch {} |
| try { |
| renderPassEncoder27.beginOcclusionQuery(179); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(2, buffer193, 24, 41); |
| } catch {} |
| try { |
| buffer158.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder28.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext9.unconfigure(); |
| } catch {} |
| try { |
| renderPassEncoder27.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer234, 'uint16', 0, 26); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline41); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 136, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(213).fill(151), /* required buffer size: 213 */ |
| {offset: 213, bytesPerRow: 279, rowsPerImage: 50}, {width: 126, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext18 = offscreenCanvas9.getContext('webgpu'); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup109); |
| } catch {} |
| try { |
| renderPassEncoder28.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer199, 'uint32', 4, 19); |
| } catch {} |
| let arrayBuffer14 = buffer173.getMappedRange(8, 4); |
| try { |
| commandEncoder208.copyBufferToTexture({ |
| /* bytesInLastRow: 240 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 112 */ |
| offset: 112, |
| bytesPerRow: 5376, |
| buffer: buffer90, |
| }, { |
| texture: texture180, |
| mipLevel: 0, |
| origin: {x: 18, y: 20, z: 0}, |
| aspect: 'all', |
| }, {width: 90, height: 100, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas10 = new OffscreenCanvas(43, 540); |
| let buffer238 = device0.createBuffer({ |
| size: 72, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture325 = device0.createTexture({ |
| size: {width: 97}, |
| dimension: '1d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView311 = texture294.createView({dimension: '2d-array'}); |
| let sampler42 = device0.createSampler({lodMaxClamp: 92.82, compare: 'less', maxAnisotropy: 1}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup160); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer176, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup100); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer107, 'uint32', 60, 300); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(1, buffer141); |
| } catch {} |
| try { |
| gpuCanvasContext12.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 20, new Uint32Array(10839).map((_, i) => i * 1), 1511, 0); |
| } catch {} |
| let gpuCanvasContext19 = offscreenCanvas10.getContext('webgpu'); |
| let buffer239 = device0.createBuffer({size: 26, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView312 = texture250.createView({label: '\u061b\u6c4b\u32e3\u0bf7\u0452\ud748\u229c\u1bda\u0e08', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer9, 'uint32', 4, 137); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline16); |
| } catch {} |
| let texture326 = device0.createTexture({size: [4], dimension: '1d', format: 'rg8sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer234, 'uint32', 20, 16); |
| } catch {} |
| let textureView313 = texture86.createView({}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer178, 'uint16', 4, 31); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup155, new Uint32Array(148), 13, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer183, 'uint32', 20, 11); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline20); |
| } catch {} |
| document.body.append(img4); |
| let bindGroup162 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 43, resource: {buffer: buffer56}}, |
| {binding: 6, resource: {buffer: buffer136}}, |
| {binding: 3, resource: textureView3}, |
| {binding: 58, resource: {buffer: buffer107}}, |
| ], |
| }); |
| let buffer240 = device0.createBuffer({ |
| size: 248, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer68, 32, 52); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup138, [0, 0]); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 43, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let texture327 = device0.createTexture({ |
| size: {width: 195, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer1, 'uint32', 88, 9); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer65, 'uint16', 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(6, buffer118, 0, 722); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer216, 4, new DataView(new ArrayBuffer(18696)), 1330, 4); |
| } catch {} |
| document.body.append(img7); |
| let imageData43 = new ImageData(20, 44); |
| let buffer241 = device0.createBuffer({size: 128, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let texture328 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer178, 'uint16', 4, 16); |
| } catch {} |
| try { |
| commandEncoder72.resolveQuerySet(querySet1, 39, 2, buffer222, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(33).fill(181), /* required buffer size: 33 */ |
| {offset: 33, rowsPerImage: 24}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup135, new Uint32Array(3053), 138, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder150.clearBuffer(buffer106); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer192, 0, new Float32Array(2909).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.737)), 19, 0); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame8.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| videoFrame29.close(); |
| videoFrame30.close(); |
| videoFrame31.close(); |
| videoFrame32.close(); |
| videoFrame33.close(); |
| videoFrame35.close(); |
| videoFrame37.close(); |
| videoFrame38.close(); |
| videoFrame39.close(); |
| videoFrame41.close(); |
| videoFrame43.close(); |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0(), window1() ]; |
| log('promises created'); |
| let results = await Promise.allSettled(promises); |
| for (let result of results) { |
| if (result.status === 'rejected') { throw result.reason; } |
| } |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| debug('Pass'); |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
