| <!-- webkit-test-runner [ enableMetalShaderValidation=true ] --> |
| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script id="shared"> |
| const log = console.log; |
| |
| async function gc() { |
| await 0; |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUComputePassEncoder} computePassEncoder |
| */ |
| function clearResourceUsages(device, computePassEncoder) { |
| let code = `@compute @workgroup_size(1) fn c() {}`; |
| let module = device.createShaderModule({code}); |
| computePassEncoder.setPipeline(device.createComputePipeline( |
| { |
| layout: 'auto', |
| compute: {module}, |
| })); |
| computePassEncoder.dispatchWorkgroups(1); |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| const videoUrls = [ |
| |
| ]; |
| |
| /** |
| * @param {number} index |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData(index) { |
| let video = document.createElement('video'); |
| video.src = videoUrls[index % videoUrls.length]; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| /** |
| * @param {string} payload |
| * @returns {string} |
| */ |
| function toBlobUrl(payload) { |
| let blob = new Blob([payload], {type: 'text/javascript'}); |
| return URL.createObjectURL(blob); |
| } |
| </script> |
| |
| <script> |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| |
| async function window0() { |
| let promise0 = navigator.gpu.requestAdapter(); |
| let adapter0 = await navigator.gpu.requestAdapter({powerPreference: 'low-power'}); |
| let device0 = await adapter0.requestDevice({ |
| defaultQueue: {}, |
| requiredLimits: { |
| maxStorageTexturesPerShaderStage: 4, |
| maxTextureDimension1D: 8192, |
| maxUniformBufferBindingSize: 50290837, |
| maxStorageBufferBindingSize: 158197003, |
| }, |
| }); |
| let texture0 = device0.createTexture({ |
| size: {width: 1}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.24, |
| }); |
| let commandEncoder0 = device0.createCommandEncoder(); |
| let texture1 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 171}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder0 = commandEncoder0.beginComputePass(); |
| let commandEncoder1 = device0.createCommandEncoder(); |
| let sampler1 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.37, |
| maxAnisotropy: 3, |
| }); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let img0 = await imageWithData(106, 5, '#10101010', '#20202020'); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let texture2 = device0.createTexture({ |
| size: [4, 1575, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder1 = commandEncoder1.beginComputePass({}); |
| let textureView0 = texture2.createView({mipLevelCount: 1}); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.label = '\u2bb2\ua96f\u5d32\u0201\ud394\u{1fd68}'; |
| } catch {} |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture3 = device0.createTexture({ |
| label: '\u08a7\u0806\ud61d\u139c\uf4e3\u0b9d\u0e68\uf084\u{1ffb6}\ucf9f\u9649', |
| size: [256, 256, 21], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 119, z: 31}, |
| aspect: 'all', |
| }, new Uint8Array(46_168).fill(144), /* required buffer size: 46_168 */ |
| {offset: 184, bytesPerRow: 24, rowsPerImage: 237}, {width: 0, height: 21, depthOrArrayLayers: 9}); |
| } catch {} |
| let textureView1 = texture3.createView({dimension: '2d'}); |
| let textureView2 = texture3.createView({dimension: 'cube', baseArrayLayer: 4}); |
| let computePassEncoder2 = commandEncoder3.beginComputePass(); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 174, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let buffer0 = device0.createBuffer({ |
| size: 14774, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let texture4 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder3 = commandEncoder4.beginComputePass({}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16sint'], |
| depthStencilFormat: 'stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let renderBundle0 = renderBundleEncoder0.finish({}); |
| await gc(); |
| let buffer1 = device0.createBuffer({size: 17471, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 1878}); |
| let texture5 = device0.createTexture({ |
| size: [419, 1, 20], |
| mipLevelCount: 6, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder4 = commandEncoder2.beginComputePass({}); |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let textureView3 = texture3.createView({dimension: 'cube', baseArrayLayer: 3}); |
| await gc(); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 202, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let texture6 = device0.createTexture({ |
| size: {width: 1, height: 273, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView4 = texture5.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder5 = commandEncoder5.beginComputePass({}); |
| let sampler2 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| device0.queue.writeBuffer(buffer1, 628, new DataView(new ArrayBuffer(5989)), 123, 2164); |
| } catch {} |
| let texture7 = device0.createTexture({ |
| size: {width: 2, height: 787, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['stencil8'], |
| }); |
| let sampler3 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 91.41}); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| document.body.append(img0); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: img0, |
| origin: { x: 2, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 38, z: 17}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder6 = device0.createCommandEncoder({label: '\u6ee5\u6317\u520a\u608f\u098f'}); |
| let sampler4 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 80.11, |
| }); |
| let computePassEncoder6 = commandEncoder6.beginComputePass({}); |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<private> vp1: mat2x4h = mat2x4h(); |
| |
| var<private> vp3 = array(modf(vec4f(0.6308, 0.1957, 0.01289, 0.02196))); |
| |
| var<workgroup> vw1: mat2x2h; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T2 { |
| @size(44) f0: array<u32>, |
| } |
| |
| var<workgroup> vw5: vec4i; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp0: mat2x3h = mat2x3h(); |
| |
| var<workgroup> vw0: atomic<i32>; |
| |
| var<workgroup> vw2: array<array<vec4<bool>, 1>, 1>; |
| |
| var<private> vp2: mat2x2f = mat2x2f(0.1132, 0.5810, -0.1639, 0.03978); |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T1 { |
| @size(44) f0: array<array<array<array<atomic<i32>, 1>, 1>, 1>>, |
| } |
| |
| struct T0 { |
| @size(48) f0: array<mat2x3f>, |
| } |
| |
| var<workgroup> vw4: array<atomic<u32>, 46>; |
| |
| struct T3 { |
| f0: vec2u, |
| f1: vec2u, |
| @align(8) @size(152) f2: array<array<array<array<array<vec2h, 5>, 1>, 1>, 1>, 1>, |
| } |
| |
| var<workgroup> vw3: bool; |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute0() { |
| let ptr0: ptr<workgroup, array<atomic<u32>, 46>> = &vw4; |
| vp0 = mat2x3h(f16(atomicLoad(&(*ptr0)[45])), f16(atomicLoad(&(*ptr0)[45])), f16(atomicLoad(&(*ptr0)[45])), f16(atomicLoad(&(*ptr0)[45])), f16(atomicLoad(&(*ptr0)[45])), f16(atomicLoad(&(*ptr0)[45]))); |
| }`, |
| }); |
| let buffer3 = device0.createBuffer({ |
| size: 4806, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 254}); |
| let texture8 = device0.createTexture({ |
| size: {width: 4}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16sint'], |
| }); |
| let computePassEncoder7 = commandEncoder7.beginComputePass({}); |
| let sampler5 = device0.createSampler({addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 84.78}); |
| let imageData0 = new ImageData(36, 32); |
| try { |
| device0.queue.label = '\u39de\uec9d\u{1fbe5}'; |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 202, resource: textureView0}, {binding: 47, resource: textureView1}], |
| }); |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let computePassEncoder8 = commandEncoder8.beginComputePass({}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(392), 155, 0); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let textureView5 = texture8.createView({baseMipLevel: 0}); |
| let sampler6 = device0.createSampler({ |
| label: '\ud79f\u0ede\u0d66\ub6cc\u9c99\u2e30\u0563\u{1f87f}\u{1f799}\u89c7\u754f', |
| addressModeU: 'mirror-repeat', |
| lodMaxClamp: 63.16, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup0); |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let textureView6 = texture0.createView({}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 796 */ |
| offset: 796, |
| bytesPerRow: 4352, |
| buffer: buffer3, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 0, y: 171, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 5, y: 48, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 36, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 72, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder3.insertDebugMarker('\u993b'); |
| } catch {} |
| let imageData1 = new ImageData(72, 4); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 202, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 202, resource: textureView0}, {binding: 47, resource: textureView1}], |
| }); |
| let texture9 = device0.createTexture({ |
| label: '\u012b\ub53a', |
| size: {width: 839, height: 1, depthOrArrayLayers: 51}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r16sint'], |
| }); |
| let computePassEncoder9 = commandEncoder9.beginComputePass({}); |
| let sampler7 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 84.52, |
| lodMaxClamp: 86.39, |
| compare: 'greater-equal', |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup1, new Uint32Array(678), 23, 0); |
| } catch {} |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let texture10 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(1885), 180, 0); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let pipeline0 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {}}}); |
| let textureView7 = texture5.createView({ |
| dimension: '2d-array', |
| aspect: 'stencil-only', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 3, |
| arrayLayerCount: 3, |
| }); |
| let computePassEncoder10 = commandEncoder10.beginComputePass({}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup0, new Uint32Array(5534), 799, 0); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.label = '\u0d02\u4187\u{1faa2}\uaadb\u{1fa4e}\ua5c7\uf3db'; |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 202, resource: textureView0}, {binding: 47, resource: textureView1}], |
| }); |
| let buffer4 = device0.createBuffer({size: 15981, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let texture11 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture12 = device0.createTexture({ |
| label: '\u52fc\u{1f8d4}\u39c1\uedd1\uf587\u2e36\u0af8\ubaa3\u00a8', |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let sampler8 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.56, |
| }); |
| let pipeline1 = await device0.createComputePipelineAsync({ |
| label: '\u4422\u{1fddd}\u{1f89d}\ubb6f\uef3a\u0614\u89a6\u8a88', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule0, entryPoint: 'compute0'}, |
| }); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let textureView8 = texture3.createView({dimension: '2d'}); |
| let texture13 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 42}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| let texture14 = device0.createTexture({ |
| size: [839, 1, 1], |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView9 = texture10.createView({dimension: '2d-array', aspect: 'stencil-only'}); |
| let computePassEncoder11 = commandEncoder11.beginComputePass({}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 47, resource: textureView1}, {binding: 202, resource: textureView0}], |
| }); |
| let textureView10 = texture11.createView({aspect: 'all'}); |
| let textureView11 = texture14.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let sampler9 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'equal', |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup3, new Uint32Array(347), 59, 0); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| let buffer5 = device0.createBuffer({size: 731, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let texture15 = device0.createTexture({ |
| label: '\u98e2\u0635\u{1ff24}\u64fa\u3f95', |
| size: {width: 2, height: 1095, depthOrArrayLayers: 247}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture16 = device0.createTexture({size: [419, 1, 1], format: 'stencil8', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let computePassEncoder12 = commandEncoder12.beginComputePass({}); |
| try { |
| computePassEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 3000, new Float32Array(8279), 63, 192); |
| } catch {} |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let texture17 = device0.createTexture({ |
| size: {width: 4, height: 1575, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| sampleCount: 1, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let pipeline2 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0}}); |
| let texture18 = device0.createTexture({ |
| size: [1678, 1, 1], |
| sampleCount: 4, |
| dimension: '2d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture19 = device0.createTexture({ |
| size: [2, 787, 1], |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView12 = texture4.createView({}); |
| try { |
| device0.queue.writeBuffer(buffer1, 6640, new BigUint64Array(9338), 2242, 360); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 31, y: 94, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(36).fill(145), /* required buffer size: 36 */ |
| {offset: 36, bytesPerRow: 287, rowsPerImage: 82}, {width: 43, height: 57, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise1 = device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule0}}); |
| await gc(); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let texture20 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture21 = device0.createTexture({ |
| size: {width: 2, height: 787, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder13 = commandEncoder13.beginComputePass(); |
| try { |
| device0.queue.writeBuffer(buffer1, 1076, new BigUint64Array(13781), 3283, 212); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 6, z: 15}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'bt709'} }); |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| requires packed_4x8_integer_dot_product; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| var<workgroup> vw6: atomic<i32>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp4: VertexOutput0 = VertexOutput0(); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentOutput0 { |
| @location(4) @interpolate(flat, center) f0: vec2f, |
| @location(0) f1: vec2i, |
| @location(3) @interpolate(flat) f2: vec4u, |
| } |
| |
| var<private> vp5 = modf(vec3h(8486.0, 19642.6, 12390.4)); |
| |
| @group(0) @binding(174) var<storage, read> buffer6: T0; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| @size(44) f0: array<u32>, |
| } |
| |
| struct VertexOutput0 { |
| @builtin(position) f0: vec4f, |
| @location(7) @interpolate(perspective, centroid) f1: vec2f, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| /* used global variables: buffer6 */ |
| fn fn0(a0: array<mat2x3f, 1>, a1: array<array<array<array<i32, 1>, 1>, 9>, 1>) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| var vf0: i32 = a1[unconst_u32(236)][8][0][0]; |
| while bool(a1[0][8][unconst_u32(122)][0]) { |
| vp4 = VertexOutput0(vec4f(f32(a1[unconst_u32(71)][8][0][0])), vec2f(f32(a1[unconst_u32(71)][8][0][0]))); |
| out.f2 |= vec4u(bitcast<u32>(a1[0][unconst_u32(486)][0][0])); |
| vp4 = VertexOutput0(vec4f(bitcast<f32>(a1[0][8][unconst_u32(24)][0])), vec2f(bitcast<f32>(a1[0][8][unconst_u32(24)][0]))); |
| } |
| var vf1: vec3h = exp(vec3h(unconst_f16(10857.4), unconst_f16(8752.6), unconst_f16(17471.1))); |
| let vf2: array<i32, 1> = a1[unconst_u32(337)][8][0]; |
| var vf3: array<i32, 1> = a1[unconst_u32(177)][unconst_u32(168)][unconst_u32(169)]; |
| let ptr1: ptr<storage, u32, read> = &buffer6.f0[u32(a1[unconst_u32(282)][8][0][0])]; |
| var vf4: f32 = vp4.f1[unconst_u32(93)]; |
| vp4 = VertexOutput0(vec4f(f32(a1[unconst_u32(384)][unconst_u32(214)][unconst_u32(33)][unconst_u32(284)])), vec2f(bitcast<f32>(a1[unconst_u32(384)][unconst_u32(214)][unconst_u32(33)][unconst_u32(284)]))); |
| return out; |
| _ = buffer6; |
| } |
| |
| /* used global variables: buffer6 */ |
| @vertex |
| fn vertex0(@location(8) a0: vec4h) -> VertexOutput0 { |
| var out: VertexOutput0; |
| if bool(exp(bitcast<vec2h>(vp4.f1[unconst_u32(279)])).y) { |
| fn0(array<mat2x3f, 1>(mat2x3f(f32(buffer6.f0[arrayLength(&buffer6.f0)]), f32(buffer6.f0[arrayLength(&buffer6.f0)]), f32(buffer6.f0[arrayLength(&buffer6.f0)]), f32(buffer6.f0[arrayLength(&buffer6.f0)]), f32(buffer6.f0[arrayLength(&buffer6.f0)]), bitcast<f32>(buffer6.f0[arrayLength(&buffer6.f0)]))), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193))).x)), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193))).z)), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193))).g)), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193)))[3])), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193)))[2])), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193)))[1])), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193))).z)), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193)))[1])), array<array<i32, 1>, 1>(array<i32, 1>((unconst_i32(-377) % vec4i(unconst_i32(-128), unconst_i32(93), unconst_i32(100), unconst_i32(193))).a))))); |
| var vf5: vec2h = refract(bitcast<vec2h>((*&buffer6).f0[unconst_u32(570)]), vec2h(unconst_f16(799.8), unconst_f16(35378.5)), unconst_f16(1265.6)); |
| fn0(array<mat2x3f, 1>(mat2x3f(unpack4x8snorm((*&buffer6).f0[unconst_u32(14)]).yzx, unpack4x8snorm((*&buffer6).f0[unconst_u32(14)]).zww)), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)])))))); |
| var vf6: f16 = a0[unconst_u32(404)]; |
| let vf7: bool = (unconst_f32(0.07586) <= unconst_f32(-0.00542)); |
| return out; |
| _ = buffer6; |
| } |
| var vf8 = fn0(array<mat2x3f, 1>(mat2x3f(vp4.f1.rrr, vp4.f1.xxy)), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(buffer6.f0[unconst_i32(230)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(buffer6.f0[unconst_i32(230)])))))); |
| let ptr2: ptr<storage, array<u32>, read> = &(*&buffer6).f0; |
| var vf9 = fn0(array<mat2x3f, 1>(mat2x3f(vec3f((vec4f(unconst_f32(0.08898), unconst_f32(0.01385), unconst_f32(-0.5640), unconst_f32(0.1732)) != vec4f(unconst_f32(0.00470), unconst_f32(0.09445), unconst_f32(0.3106), unconst_f32(0.06449))).yzz), vec3f((vec4f(unconst_f32(0.08898), unconst_f32(0.01385), unconst_f32(-0.5640), unconst_f32(0.1732)) != vec4f(unconst_f32(0.00470), unconst_f32(0.09445), unconst_f32(0.3106), unconst_f32(0.06449))).ggg))), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[unconst_u32(94)])))))); |
| if bool(vf8.f0[1]) { |
| let ptr3: ptr<storage, array<u32>, read> = &buffer6.f0; |
| _ = buffer6; |
| } |
| while bool(vf8.f1[unconst_u32(51)]) { |
| let ptr4: ptr<storage, u32, read> = &buffer6.f0[arrayLength(&buffer6.f0)]; |
| out.f0 = vec4f(log2(vec3h(unconst_f16(-24556.7), unconst_f16(3228.8), unconst_f16(3336.2))).ggbg); |
| vp4.f1 = vec2f(f32(arrayLength(&buffer6.f0))); |
| if bool(degrees(vec4f(unconst_f32(0.08147), unconst_f32(0.07067), unconst_f32(0.1506), unconst_f32(0.1256))).g) { |
| fn0(array<mat2x3f, 1>(mat2x3f(bitcast<f32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]), bitcast<f32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]), f32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]), f32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]), f32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]), f32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5))))[2])), array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5)))).b)), array<array<i32, 1>, 1>(array<i32, 1>(i32(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5))).g))), array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5))))[3])), array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5))))[2])), array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5))))[0])), array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5)))).b)), array<array<i32, 1>, 1>(array<i32, 1>(vec4i(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5)))).x)), array<array<i32, 1>, 1>(array<i32, 1>(i32(acosh(vec4h(unconst_f16(1947.1), unconst_f16(6034.9), unconst_f16(1186.5), unconst_f16(14295.5))).w)))))); |
| for (var it0=vec3u(cross(vec3f(unconst_f32(0.3885), unconst_f32(0.5456), unconst_f32(0.1485)), vec3f(unconst_f32(-0.02032), unconst_f32(0.1128), unconst_f32(0.1366))))[2]; it0<buffer6.f0[arrayLength(&buffer6.f0)]; it0++) { |
| out.f0 *= unpack4x8snorm((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]); |
| break; |
| _ = buffer6; |
| } |
| fn0(array<mat2x3f, 1>(mat2x3f(cos(unconst_f32(0.2421)), cos(unconst_f32(0.2421)), cos(unconst_f32(0.2421)), cos(unconst_f32(0.2421)), cos(unconst_f32(0.2421)), cos(unconst_f32(0.2421)))), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(i32(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(i32(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(i32(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(i32(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(i32(arrayLength(&(*&buffer6).f0)))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>(arrayLength(&(*&buffer6).f0))))))); |
| break; |
| _ = buffer6; |
| } |
| fn0(array<mat2x3f, 1>(mat2x3f(f32(dot4I8Packed(pack2x16unorm(vec2f(unconst_f32(0.01436), unconst_f32(0.02815))), unconst_u32(268))), bitcast<f32>(dot4I8Packed(pack2x16unorm(vec2f(unconst_f32(0.01436), unconst_f32(0.02815))), unconst_u32(268))), bitcast<f32>(dot4I8Packed(pack2x16unorm(vec2f(unconst_f32(0.01436), unconst_f32(0.02815))), unconst_u32(268))), f32(dot4I8Packed(pack2x16unorm(vec2f(unconst_f32(0.01436), unconst_f32(0.02815))), unconst_u32(268))), f32(dot4I8Packed(pack2x16unorm(vec2f(unconst_f32(0.01436), unconst_f32(0.02815))), unconst_u32(268))), f32(dot4I8Packed(pack2x16unorm(vec2f(unconst_f32(0.01436), unconst_f32(0.02815))), unconst_u32(268))))), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all(unconst_bool(true)))))))); |
| return out; |
| _ = buffer6; |
| } |
| vp4 = VertexOutput0(vec4f(f32(atanh(unconst_f16(13111.1)))), vec2f(f32(atanh(unconst_f16(13111.1))))); |
| return out; |
| _ = buffer6; |
| } |
| |
| /* used global variables: buffer6 */ |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| out.f1 *= bitcast<vec2i>(cross(vec3f(unconst_f32(0.01026), unconst_f32(0.1000), unconst_f32(0.1707)), cross(vec3f(unconst_f32(0.2053), unconst_f32(0.1013), unconst_f32(0.06794)), vp4.f0.yzx)).yx); |
| out.f0 *= vec2f(f32(buffer6.f0[arrayLength(&buffer6.f0)])); |
| while bool(vp4.f0[unconst_u32(122)]) { |
| for (var it1=(*&buffer6).f0[unconst_i32(410)]; it1<bitcast<vec3u>(sin(vec3f(unconst_f32(0.2366), unconst_f32(0.2420), unconst_f32(0.4868))))[2]; it1++) { |
| out.f2 |= vec4u(arrayLength(&(*&buffer6).f0)); |
| out = FragmentOutput0(vec2f(cos(bitcast<vec2h>((*&buffer6).f0[unconst_u32(140)]))), vec2i(cos(bitcast<vec2h>((*&buffer6).f0[unconst_u32(140)]))), vec4u(cos(bitcast<vec2h>((*&buffer6).f0[unconst_u32(140)])).ggrg)); |
| vp5 = modf(vec3h(f16(reverseBits(u32(vp4.f0[unconst_u32(184)]))))); |
| fn0(array<mat2x3f, 1>(transpose(transpose(mat2x3f()))), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(i32((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)]))), array<array<i32, 1>, 1>(array<i32, 1>(bitcast<i32>((*&buffer6).f0[arrayLength(&(*&buffer6).f0)])))))); |
| out = FragmentOutput0(vec2f(f32(arrayLength(&(*&buffer6).f0))), vec2i(i32(arrayLength(&(*&buffer6).f0))), unpack4xU8(arrayLength(&(*&buffer6).f0))); |
| _ = buffer6; |
| } |
| let vf10: f16 = dot(vec3h(unconst_f16(3831.3), unconst_f16(1846.7), unconst_f16(1418.9)), vec3h(unconst_f16(1020.3), unconst_f16(37395.6), unconst_f16(20692.0))); |
| var vf11: vec3f = sin(vec3f(unconst_f32(0.2462), unconst_f32(0.08568), unconst_f32(0.05655))); |
| var vf12 = fn0(array<mat2x3f, 1>(mat2x3f(vp4.f1[unconst_u32(21)], vp4.f1[unconst_u32(21)], vp4.f1[unconst_u32(21)], vp4.f1[unconst_u32(21)], vp4.f1[unconst_u32(21)], vp4.f1[unconst_u32(21)])), array<array<array<array<i32, 1>, 1>, 9>, 1>(array<array<array<i32, 1>, 1>, 9>(array<array<i32, 1>, 1>(array<i32, 1>(vec2i((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309)))).x)), array<array<i32, 1>, 1>(array<i32, 1>(i32(all((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(any((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(all((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))))), array<array<i32, 1>, 1>(array<i32, 1>(vec2i((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))[1])), array<array<i32, 1>, 1>(array<i32, 1>(i32(any((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))))), array<array<i32, 1>, 1>(array<i32, 1>(i32(any((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309))))))), array<array<i32, 1>, 1>(array<i32, 1>(vec2i((vec2f(unconst_f32(0.00209), unconst_f32(0.09453)) > vec2f(unconst_f32(0.00926), unconst_f32(0.02309)))).g))))); |
| _ = buffer6; |
| } |
| let ptr5: ptr<storage, u32, read> = &(*&buffer6).f0[arrayLength(&(*&buffer6).f0)]; |
| if bool(buffer6.f0[arrayLength(&buffer6.f0)]) { |
| let vf13: vec4h = radians(vec4h(unconst_f16(12528.8), unconst_f16(2210.2), unconst_f16(16128.8), unconst_f16(6209.8))); |
| } |
| let ptr6: ptr<private, vec4f> = &vp4.f0; |
| return out; |
| _ = buffer6; |
| } |
| |
| /* used global variables: buffer6 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute1() { |
| let vf14: u32 = arrayLength(&buffer6.f0); |
| return; |
| _ = buffer6; |
| }`, |
| }); |
| let texture22 = device0.createTexture({ |
| size: [1, 136, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView13 = texture12.createView({}); |
| let computePassEncoder14 = commandEncoder14.beginComputePass({}); |
| let sampler10 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'nearest'}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| let buffer7 = device0.createBuffer({ |
| size: 3830, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let texture23 = device0.createTexture({ |
| size: [256, 256, 21], |
| mipLevelCount: 5, |
| sampleCount: 1, |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup1); |
| } catch {} |
| let promise2 = device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| multisample: {count: 4, mask: 0x25997163}, |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'r16sint'}]}, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'greater-equal', depthFailOp: 'replace', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'never', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'replace'}, |
| stencilReadMask: 116557698, |
| stencilWriteMask: 378321618, |
| depthBiasSlopeScale: 0.0, |
| }, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 64, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x4', offset: 4, shaderLocation: 8}], |
| }, |
| ], |
| }, |
| }); |
| let texture24 = device0.createTexture({ |
| size: [256, 256, 294], |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder13.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder15.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2888 */ |
| offset: 2888, |
| bytesPerRow: 40448, |
| buffer: buffer4, |
| }, { |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 0, y: 144, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture25 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture26 = device0.createTexture({ |
| size: {width: 4, height: 1575, depthOrArrayLayers: 11}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView14 = texture7.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder15.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 266 */ |
| offset: 266, |
| bytesPerRow: 4096, |
| buffer: buffer4, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer7, offset: 2560, size: 1008}}], |
| }); |
| let commandEncoder16 = device0.createCommandEncoder(); |
| let texture27 = device0.createTexture({ |
| size: [1, 136, 1], |
| mipLevelCount: 2, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView15 = texture4.createView({baseMipLevel: 0}); |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 690 */ |
| offset: 690, |
| buffer: buffer4, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView16 = texture24.createView({}); |
| let texture28 = device0.createTexture({size: [1, 136, 1], mipLevelCount: 1, format: 'r16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let computePassEncoder15 = commandEncoder15.beginComputePass(); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup2, new Uint32Array(610), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3448 */ |
| offset: 3448, |
| bytesPerRow: 7168, |
| buffer: buffer4, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let textureView17 = texture11.createView({aspect: 'all'}); |
| let textureView18 = texture21.createView({dimension: '2d-array', aspect: 'stencil-only', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup4, new Uint32Array(683), 6, 1); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let textureView19 = texture18.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline2); |
| } catch {} |
| let videoFrame1 = videoFrame0.clone(); |
| let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder19 = device0.createCommandEncoder(); |
| let texture29 = device0.createTexture({ |
| size: [1678, 1, 21], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture30 = device0.createTexture({ |
| size: {width: 2, height: 787, depthOrArrayLayers: 137}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView20 = texture25.createView({ |
| label: '\u0408\u056f\u{1fbf8}\u32a9\u092e\ubb8d\u3402\u0a2c\u{1fc9c}\u49e0', |
| dimension: '2d', |
| format: 'depth16unorm', |
| }); |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(6, 31); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let texture31 = device0.createTexture({ |
| size: [1, 393, 1], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder19.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 496 */ |
| offset: 496, |
| buffer: buffer4, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame2 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| let texture32 = device0.createTexture({ |
| size: [839], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder2.insertDebugMarker('\u4bc6'); |
| } catch {} |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let texture33 = device0.createTexture({ |
| size: [2, 787, 1], |
| mipLevelCount: 2, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView21 = texture16.createView({dimension: '2d-array', aspect: 'stencil-only'}); |
| let computePassEncoder16 = commandEncoder20.beginComputePass({}); |
| try { |
| computePassEncoder10.setPipeline(pipeline2); |
| } catch {} |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 840}); |
| let textureView22 = texture15.createView({mipLevelCount: 1}); |
| let textureView23 = texture9.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 9}); |
| let computePassEncoder17 = commandEncoder19.beginComputePass({}); |
| try { |
| computePassEncoder1.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 0, y: 56, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(46).fill(186), /* required buffer size: 46 */ |
| {offset: 46, bytesPerRow: 151}, {width: 0, height: 23, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView24 = texture27.createView({mipLevelCount: 1}); |
| let sampler11 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.95, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup4, new Uint32Array(566), 89, 1); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2116 */ |
| offset: 2116, |
| buffer: buffer4, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 1680, new Float32Array(169), 139, 16); |
| } catch {} |
| try { |
| offscreenCanvas0.getContext('bitmaprenderer'); |
| } catch {} |
| let textureView25 = texture23.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 6}); |
| let texture34 = device0.createTexture({ |
| size: {width: 1, height: 273, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView26 = texture24.createView({}); |
| let computePassEncoder18 = commandEncoder17.beginComputePass({}); |
| try { |
| computePassEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2210 */ |
| offset: 2210, |
| bytesPerRow: 18944, |
| buffer: buffer4, |
| }, { |
| texture: texture19, |
| mipLevel: 2, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 99, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 47, resource: textureView1}, {binding: 202, resource: textureView0}], |
| }); |
| let texture35 = device0.createTexture({ |
| size: [1, 547, 1], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture36 = device0.createTexture({ |
| size: {width: 1, height: 547, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder19 = commandEncoder18.beginComputePass({}); |
| let sampler12 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder5.insertDebugMarker('\ub34a'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 472, new Float32Array(24672), 3025, 8); |
| } catch {} |
| let texture37 = device0.createTexture({ |
| size: [1], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture38 = device0.createTexture({ |
| size: [1, 196, 1], |
| mipLevelCount: 5, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView27 = texture36.createView({mipLevelCount: 1}); |
| let computePassEncoder20 = commandEncoder21.beginComputePass({}); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup4, [0]); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup4, new Uint32Array(1405), 85, 1); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let textureView28 = texture37.createView({}); |
| let textureView29 = texture18.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder21 = commandEncoder16.beginComputePass({}); |
| let buffer8 = device0.createBuffer({size: 4907, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView30 = texture35.createView({}); |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder0.insertDebugMarker('\u5311'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 168, new DataView(new ArrayBuffer(3701)), 436, 24); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 171} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 515, z: 15}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline3 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0}}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(4502), 493, 1); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline0); |
| } catch {} |
| let textureView31 = texture24.createView({}); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder22 = device0.createCommandEncoder(); |
| let texture39 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 15}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture40 = device0.createTexture({ |
| size: {width: 2, height: 787, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler13 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| commandEncoder22.copyBufferToBuffer(buffer4, 124, buffer1, 3084, 1140); |
| } catch {} |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 312 */ |
| offset: 312, |
| bytesPerRow: 768, |
| buffer: buffer3, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder22 = commandEncoder22.beginComputePass({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup2, []); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup0, new Uint32Array(1414), 108, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 208, new DataView(new ArrayBuffer(10708)), 1222, 496); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 1, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 188, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder23 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder16.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder23.clearBuffer(buffer0, 116, 940); |
| } catch {} |
| let pipeline4 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule1, constants: {}}}); |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 47, resource: textureView8}, {binding: 202, resource: textureView0}], |
| }); |
| let textureView32 = texture7.createView({aspect: 'stencil-only', mipLevelCount: 1}); |
| let computePassEncoder23 = commandEncoder23.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer5, 244); }; |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 152, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(320).fill(249), /* required buffer size: 320 */ |
| {offset: 320, bytesPerRow: 31}, {width: 0, height: 263, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView33 = texture11.createView({mipLevelCount: 1}); |
| let sampler14 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 94.62, |
| }); |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline2); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 77, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 432, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup7 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer3, offset: 256, size: 584}}], |
| }); |
| let textureView34 = texture27.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let textureView35 = texture5.createView({dimension: '2d', mipLevelCount: 2, baseArrayLayer: 4}); |
| let sampler15 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.95, |
| compare: 'less-equal', |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup2, []); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(946), 17, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder10.copyBufferToBuffer(buffer5, 224, buffer8, 160, 100); |
| } catch {} |
| document.body.append(img0); |
| let texture41 = device0.createTexture({ |
| size: {width: 2}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder24 = commandEncoder10.beginComputePass({}); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(img0); |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 360, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 47, resource: textureView8}, {binding: 202, resource: textureView0}], |
| }); |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthStencilFormat: 'stencil8', sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup5); |
| } catch {} |
| let texture42 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder25 = commandEncoder24.beginComputePass({}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } 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 texture43 = device0.createTexture({ |
| label: '\ubf07\u{1fcdc}\u04a8\ucc8d\u{1f67c}\u{1fb51}\uc7e7\u394f\u4949\ua5e2', |
| size: [1, 547, 1], |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['stencil8'], |
| }); |
| let textureView36 = texture18.createView({label: '\u687e\u2588', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup0); |
| } catch {} |
| let promise4 = device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule0}}); |
| let renderBundle1 = renderBundleEncoder1.finish({}); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup2, new Uint32Array(329), 31, 0); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let buffer9 = device0.createBuffer({size: 35981, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer0, offset: 7680, size: 1616}}], |
| }); |
| let querySet3 = device0.createQuerySet({type: 'occlusion', count: 498}); |
| let computePassEncoder26 = commandEncoder15.beginComputePass({}); |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| let texture44 = device0.createTexture({ |
| size: [839, 1, 124], |
| mipLevelCount: 7, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder26.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| let texture45 = device0.createTexture({ |
| size: [1, 547, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture46 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup5, new Uint32Array(1008), 154, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer5, 384); }; |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 56, z: 23}, |
| aspect: 'all', |
| }, new Uint8Array(16_358).fill(192), /* required buffer size: 16_358 */ |
| {offset: 58, bytesPerRow: 28, rowsPerImage: 101}, {width: 1, height: 78, depthOrArrayLayers: 6}); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder(); |
| let texture47 = device0.createTexture({ |
| size: [1678, 1, 1], |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline2); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fd7d}\u6125'; |
| } catch {} |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let texture48 = device0.createTexture({size: [2, 1095, 1], format: 'stencil8', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let sampler16 = device0.createSampler({lodMaxClamp: 97.97}); |
| let texture49 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder23.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 2, |
| origin: {x: 0, y: 17, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(38).fill(32), /* required buffer size: 38 */ |
| {offset: 38, bytesPerRow: 226, rowsPerImage: 45}, {width: 0, height: 23, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer10 = device0.createBuffer({size: 2607, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let textureView37 = texture29.createView({baseMipLevel: 0}); |
| let texture50 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView38 = texture38.createView({baseMipLevel: 1, mipLevelCount: 1}); |
| let computePassEncoder27 = commandEncoder28.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let textureView39 = texture23.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 6}); |
| let textureView40 = texture37.createView({format: 'rgba16sint', arrayLayerCount: 1}); |
| let computePassEncoder28 = commandEncoder27.beginComputePass({}); |
| try { |
| computePassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder30 = device0.createCommandEncoder(); |
| let computePassEncoder29 = commandEncoder26.beginComputePass({}); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup7, new Uint32Array(204), 8, 1); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder4.insertDebugMarker('\u19b5'); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt470m', transfer: 'smpteSt4281'} }); |
| let texture51 = device0.createTexture({ |
| size: [419, 1, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder30 = commandEncoder30.beginComputePass({}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup7, [0]); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup0, new Uint32Array(1098), 1, 0); |
| } catch {} |
| try { |
| commandEncoder17.copyTextureToBuffer({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 28, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 360 */ |
| offset: 360, |
| bytesPerRow: 17152, |
| buffer: buffer3, |
| }, {width: 0, height: 25, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer8, 820, 68); |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer0, offset: 1536, size: 3328}}], |
| }); |
| let buffer11 = device0.createBuffer({ |
| size: 7941, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder31 = device0.createCommandEncoder(); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 1571}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup9, [512]); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToBuffer(buffer11, 4428, buffer0, 4576, 408); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| struct VertexOutput1 { |
| @invariant @builtin(position) f2: vec4f, |
| } |
| |
| struct T3 { |
| @size(44) f0: array<atomic<i32>>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp6 = modf(f16(8602.1)); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: buffer12 */ |
| fn fn0() -> array<mat2x3h, 1> { |
| var out: array<mat2x3h, 1>; |
| out[unconst_u32(109)] = mat2x3h((*&buffer12)[unconst_u32(14)][0].yyy, (*&buffer12)[unconst_u32(14)][0].yyx); |
| var vf15: i32 = dot4I8Packed(unconst_u32(623), unconst_u32(150)); |
| let ptr7: ptr<storage, array<vec2h, 1>, read> = &(*&buffer12)[10]; |
| let ptr8: ptr<storage, array<vec2h, 1>, read> = &(*ptr7); |
| vp6 = modf(buffer12[10][0].y); |
| vp6 = modf(f16(insertBits(vec3i(unconst_i32(14), unconst_i32(252), unconst_i32(39)), vec3i(unconst_i32(295), unconst_i32(63), unconst_i32(159)), unconst_u32(79), unconst_u32(119)).b)); |
| let ptr9: ptr<storage, vec2h, read> = &(*&buffer12)[10][unconst_u32(22)]; |
| vp7[37] = f16(sqrt(unconst_f32(0.3741))); |
| let ptr10: ptr<storage, vec2h, read> = &buffer12[unconst_u32(55)][unconst_u32(127)]; |
| return out; |
| _ = buffer12; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T1 { |
| @size(48) f0: array<mat4x4h>, |
| } |
| |
| struct T0 { |
| @size(44) f0: array<array<atomic<u32>, 5>>, |
| } |
| |
| @group(0) @binding(174) var<storage, read> buffer12: array<array<vec2h, 1>, 11>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp7: array<f16, 38> = array(f16(1480.9), f16(4615.3), f16(-13789.0), f16(1902.2), f16(-6965.3), f16(768.7), f16(3905.2), f16(6269.9), f16(6435.1), f16(-2159.5), f16(1631.4), f16(4007.4), f16(1061.5), f16(706.5), f16(2089.2), f16(-4350.7), f16(2029.0), f16(6323.4), f16(4213.2), f16(9422.2), f16(7554.2), f16(-5140.4), f16(1693.4), f16(5685.4), f16(-44164.4), f16(2674.8), f16(552.5), f16(19114.6), f16(4525.2), f16(3436.3), f16(29507.9), f16(1721.6), f16(26009.8), f16(1789.7), f16(3781.4), f16(4789.7), f16(16462.0), f16(3840.6)); |
| |
| struct T2 { |
| @size(44) f0: f32, |
| } |
| |
| /* used global variables: buffer12 */ |
| @vertex |
| fn vertex1(@location(12) @interpolate(perspective) a0: vec2h, @location(15) @interpolate(perspective, center) a1: vec2f, @location(9) a2: f32, @location(2) @interpolate(flat) a3: u32) -> VertexOutput1 { |
| var out: VertexOutput1; |
| vp7[unconst_u32(79)] -= buffer12[10][0].r; |
| out.f2 *= vec4f((*&buffer12)[unconst_u32(9)][0].xyxy); |
| out = VertexOutput1(vec4f((*&buffer12)[unconst_u32(115)][0].xyyy)); |
| let ptr11: ptr<storage, array<vec2h, 1>, read> = &buffer12[10]; |
| out.f2 -= vec4f(buffer12[unconst_u32(79)][0].rgrr); |
| vp7[bitcast<u32>(buffer12[unconst_u32(344)][0])] = vec4h(tanh(vec4f(unconst_f32(0.01158), unconst_f32(0.3207), unconst_f32(0.2735), unconst_f32(0.07404)))).g; |
| loop { |
| out.f2 = vec4f(f32((*&buffer12)[10][0][unconst_u32(326)])); |
| var vf16: vec3u = select(vec3u(unconst_u32(223), unconst_u32(87), unconst_u32(26)), vec3u(unconst_u32(167), unconst_u32(34), unconst_u32(29)), unconst_bool(false)); |
| fn0(); |
| fn0(); |
| let ptr12: ptr<private, f16> = &vp6.fract; |
| break; |
| _ = buffer12; |
| } |
| var vf17: vec4h = min(vec4h(unconst_f16(9541.8), unconst_f16(965.1), unconst_f16(5545.6), unconst_f16(13610.7)), vec4h(unconst_f16(5765.1), unconst_f16(418.0), unconst_f16(-5796.4), unconst_f16(12453.6))); |
| fn0(); |
| return out; |
| _ = buffer12; |
| } |
| |
| /* used global variables: buffer12 */ |
| @compute @workgroup_size(1, 2, 2) |
| fn compute2() { |
| storageBarrier(); |
| var vf18: bool = (unconst_bool(true) && unconst_bool(false)); |
| let vf19: f16 = buffer12[bitcast<u32>((*&buffer12)[10][unconst_u32(45)])][0][unconst_u32(111)]; |
| var vf20: f16 = buffer12[unconst_u32(123)][0][unconst_u32(205)]; |
| let vf21: f16 = (*&buffer12)[10][unconst_u32(29)][unconst_u32(15)]; |
| let ptr13: ptr<storage, vec2h, read> = &(*&buffer12)[10][unconst_u32(173)]; |
| let vf22: vec4i = unpack4xI8(unconst_u32(481)); |
| let ptr14: ptr<storage, vec2h, read> = &buffer12[unconst_u32(25)][0]; |
| _ = buffer12; |
| }`, |
| }); |
| let recycledExplicitBindGroupLayout2 = pipeline0.getBindGroupLayout(0); |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 47, resource: textureView8}, {binding: 202, resource: textureView0}], |
| }); |
| let buffer13 = device0.createBuffer({size: 2922, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture52 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture53 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder31 = commandEncoder29.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 171} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 22, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 130, z: 7}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView41 = texture15.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); }; |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let textureView42 = texture17.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup0, new Uint32Array(3539), 167, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline3); |
| } catch {} |
| let texture54 = device0.createTexture({ |
| size: {width: 1, height: 547, depthOrArrayLayers: 385}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView43 = texture44.createView({dimension: '2d', aspect: 'all', mipLevelCount: 4, baseArrayLayer: 108}); |
| try { |
| computePassEncoder21.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToBuffer(buffer5, 156, buffer1, 1892, 228); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1096 */ |
| offset: 1096, |
| bytesPerRow: 16384, |
| rowsPerImage: 605, |
| buffer: buffer4, |
| }, { |
| texture: texture21, |
| mipLevel: 1, |
| origin: {x: 0, y: 5, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer14 = device0.createBuffer({ |
| size: 15546, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let texture55 = device0.createTexture({ |
| size: [1678, 1, 40], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder32 = commandEncoder31.beginComputePass({}); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup2, new Uint32Array(828), 74, 0); |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToBuffer(buffer5, 56, buffer10, 44, 4); |
| } catch {} |
| let pipeline5 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule1}}); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let textureView44 = texture17.createView({dimension: '2d-array', mipLevelCount: 3, baseArrayLayer: 0}); |
| let texture56 = device0.createTexture({ |
| size: [256, 256, 21], |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder33 = commandEncoder33.beginComputePass(); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup4, new Uint32Array(892), 35, 1); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 171} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 290, z: 99}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer15 = device0.createBuffer({ |
| size: 5987, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let textureView45 = texture54.createView({mipLevelCount: 1}); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 93.50, |
| compare: 'greater', |
| maxAnisotropy: 1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(1, 1, 2); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 844, new DataView(new ArrayBuffer(5761)), 248, 428); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 85, z: 5}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 47, resource: textureView8}, {binding: 202, resource: textureView42}], |
| }); |
| let buffer16 = device0.createBuffer({ |
| size: 2597, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture57 = device0.createTexture({ |
| size: [839, 1, 10], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView46 = texture16.createView({dimension: '2d-array', aspect: 'stencil-only', format: 'stencil8', baseMipLevel: 0, arrayLayerCount: 1}); |
| let computePassEncoder34 = commandEncoder35.beginComputePass(); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup9, [512]); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup4, new Uint32Array(404), 72, 1); |
| } catch {} |
| try { |
| computePassEncoder34.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 408, new DataView(new ArrayBuffer(307)), 100, 32); |
| } catch {} |
| let commandBuffer0 = commandEncoder17.finish(); |
| let textureView47 = texture57.createView({}); |
| let texture58 = device0.createTexture({size: [256, 256, 21], mipLevelCount: 6, format: 'stencil8', usage: GPUTextureUsage.COPY_DST}); |
| let textureView48 = texture37.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder33.setPipeline(pipeline3); |
| } catch {} |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt2020', transfer: 'bt709'} }); |
| let computePassEncoder35 = commandEncoder34.beginComputePass({}); |
| let sampler18 = device0.createSampler({addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 82.63}); |
| try { |
| computePassEncoder35.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer13, 212, 872); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| label: '\uae79\u{1f9cb}\u8a66\u{1fa63}\u{1f634}\u0e1f\u3e0e', |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 432, resource: textureView42}, {binding: 77, resource: textureView1}], |
| }); |
| let texture59 = device0.createTexture({ |
| size: [256, 256, 21], |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView49 = texture18.createView({label: '\u08ca\u0ec0', aspect: 'all', mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder36 = commandEncoder32.beginComputePass({}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup7, [256]); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 0, y: 79, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 72 */ |
| offset: 72, |
| bytesPerRow: 6144, |
| buffer: buffer8, |
| }, {width: 0, height: 25, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 408, new Float32Array(27176), 2118, 172); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer14, offset: 2816, size: 2936}}], |
| }); |
| let buffer17 = device0.createBuffer({ |
| size: 11387, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup8, new Uint32Array(2273), 325, 0); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 960 widthInBlocks: 120 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 632 */ |
| offset: 632, |
| buffer: buffer16, |
| }, { |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 120, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture60 = device0.createTexture({ |
| size: [256, 256, 3], |
| mipLevelCount: 6, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder37 = commandEncoder36.beginComputePass({}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup10, [1792]); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToBuffer(buffer14, 2356, buffer3, 1776, 488); |
| } catch {} |
| let texture61 = device0.createTexture({ |
| size: {width: 4}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder37.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 62 widthInBlocks: 31 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 208 */ |
| offset: 208, |
| bytesPerRow: 50176, |
| buffer: buffer3, |
| }, { |
| texture: texture47, |
| mipLevel: 2, |
| origin: {x: 25, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 14, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 28, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 34, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 495, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let computePassEncoder38 = commandEncoder25.beginComputePass({}); |
| try { |
| computePassEncoder38.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| await buffer1.mapAsync(GPUMapMode.READ, 0, 3108); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 132, new Int16Array(10134), 1467, 60); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout1]}); |
| try { |
| computePassEncoder37.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 8444, new BigUint64Array(26188), 8679, 552); |
| } catch {} |
| let buffer18 = device0.createBuffer({size: 16851, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture62 = device0.createTexture({size: [2, 1095, 1], mipLevelCount: 5, format: 'rgba8snorm', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup6, new Uint32Array(1670), 128, 0); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer19 = device0.createBuffer({ |
| size: 6705, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder37 = device0.createCommandEncoder({label: '\u0291\u53c9\uc432\u0e3e\u{1f646}\u7a4b\u0139\u{1ff67}\u9064'}); |
| let texture63 = device0.createTexture({ |
| size: [2, 1095, 7], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder39 = commandEncoder37.beginComputePass({}); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup1, new Uint32Array(1906), 373, 0); |
| } catch {} |
| let arrayBuffer0 = buffer1.getMappedRange(1456, 680); |
| let pipeline6 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule0}}); |
| document.body.append(img0); |
| let texture64 = device0.createTexture({ |
| label: '\u6e39\ub3ba', |
| size: [1, 547, 1], |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler19 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.40, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup14, [0]); |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer20 = device0.createBuffer({ |
| size: 177, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture65 = device0.createTexture({size: [2, 787, 1], mipLevelCount: 3, format: 'stencil8', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView50 = texture31.createView({baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 209, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let commandEncoder38 = device0.createCommandEncoder(); |
| let texture66 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 14}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| commandEncoder38.copyBufferToTexture({ |
| /* bytesInLastRow: 248 widthInBlocks: 124 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 236 */ |
| offset: 236, |
| buffer: buffer4, |
| }, { |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 124, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 171} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 245, z: 55}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView51 = texture66.createView({dimension: '2d', format: 'rgba16float', baseArrayLayer: 11}); |
| let computePassEncoder40 = commandEncoder38.beginComputePass(); |
| try { |
| computePassEncoder29.end(); |
| } catch {} |
| try { |
| computePassEncoder14.end(); |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 102 */ |
| offset: 102, |
| buffer: buffer5, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder26.resolveQuerySet(querySet3, 52, 56, buffer19, 1280); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 264, new Float32Array(1844), 199, 136); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| label: '\u1954\ud897\u065d\ufd00\u{1f844}\u0d3f\u0add\u436f', |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer11, offset: 768, size: 344}}], |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup4, new Uint32Array(10000), 1_150, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(102).fill(244), /* required buffer size: 102 */ |
| {offset: 102}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer11, offset: 768, size: 1620}}], |
| }); |
| let sampler20 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.15, |
| }); |
| try { |
| commandEncoder14.copyBufferToBuffer(buffer16, 192, buffer1, 2948, 240); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToTexture({ |
| /* bytesInLastRow: 1832 widthInBlocks: 229 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2184 */ |
| offset: 2184, |
| bytesPerRow: 39680, |
| buffer: buffer3, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 229, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder26.clearBuffer(buffer3, 2200, 964); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 77, resource: textureView27}, {binding: 432, resource: textureView42}], |
| }); |
| let textureView52 = texture17.createView({dimension: '2d-array', format: 'rgba8snorm', mipLevelCount: 1, baseArrayLayer: 0}); |
| let textureView53 = texture23.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| let computePassEncoder41 = commandEncoder14.beginComputePass({}); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline3); |
| } catch {} |
| let buffer21 = device0.createBuffer({ |
| size: 19208, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let texture67 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 26}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 78.90, |
| lodMaxClamp: 97.98, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup0); |
| } catch {} |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let textureView54 = texture61.createView({mipLevelCount: 1}); |
| let sampler23 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 96.18, |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 171} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 81, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\u100e\u38bb\ub61b\u05d4\u6d2b'; |
| } catch {} |
| let texture68 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 80}, |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder42 = commandEncoder26.beginComputePass(); |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup11, new Uint32Array(1343), 1, 0); |
| } catch {} |
| try { |
| commandEncoder39.copyBufferToBuffer(buffer14, 732, buffer9, 8388, 372); |
| } catch {} |
| let buffer22 = device0.createBuffer({ |
| size: 5964, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let computePassEncoder43 = commandEncoder41.beginComputePass(); |
| try { |
| computePassEncoder42.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 128, new Int16Array(2156), 74, 1544); |
| } catch {} |
| document.body.prepend(img0); |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let textureView55 = texture15.createView({dimension: '3d', mipLevelCount: 1}); |
| let sampler24 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 60.66}); |
| let arrayBuffer1 = buffer1.getMappedRange(2136, 360); |
| try { |
| device0.queue.writeBuffer(buffer11, 1392, new Int16Array(5460), 3567, 456); |
| } catch {} |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpteRp431', transfer: 'iec61966-2-1'} }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup8); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup18 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer15, offset: 0, size: 1608}}], |
| }); |
| let computePassEncoder44 = commandEncoder40.beginComputePass(); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup12, new Uint32Array(284), 25, 0); |
| } catch {} |
| let imageData2 = new ImageData(132, 20); |
| let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let texture69 = device0.createTexture({ |
| size: {width: 1}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder45 = commandEncoder42.beginComputePass(); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 96.49, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup16, [0]); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer3, offset: 512, size: 1156}}], |
| }); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let texture70 = device0.createTexture({ |
| size: [839], |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler26 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat'}); |
| try { |
| computePassEncoder28.setBindGroup(0, bindGroup5, new Uint32Array(82), 17, 0); |
| } catch {} |
| try { |
| textureView55.label = '\u{1fd70}\uc4f2\u0e66\u08c5\u8d49'; |
| } catch {} |
| let buffer23 = device0.createBuffer({size: 18432, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let texture71 = device0.createTexture({ |
| size: [3357, 1, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthStencilFormat: 'stencil8', sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup16, new Uint32Array(4228), 360, 1); |
| } catch {} |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 400 */ |
| offset: 400, |
| bytesPerRow: 13824, |
| buffer: buffer23, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 273, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder31.insertDebugMarker('\u{1fcc0}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 1564, new Float32Array(7288), 1235, 20); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(188).fill(255), /* required buffer size: 188 */ |
| {offset: 188, rowsPerImage: 104}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer11, offset: 1536, size: 1696}}], |
| }); |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let commandEncoder45 = device0.createCommandEncoder(); |
| let texture72 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder46 = commandEncoder44.beginComputePass({}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthStencilFormat: 'stencil8', sampleCount: 4, stencilReadOnly: false}); |
| let renderBundle2 = renderBundleEncoder3.finish({}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup18, [768]); |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup11, new Uint32Array(576), 28, 0); |
| } catch {} |
| try { |
| commandEncoder39.copyTextureToBuffer({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 92, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 28 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1310 */ |
| offset: 1310, |
| buffer: buffer18, |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 1600, new Float32Array(576), 19, 64); |
| } catch {} |
| let imageData3 = new ImageData(20, 4); |
| let buffer24 = device0.createBuffer({size: 1355, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let renderBundle3 = renderBundleEncoder2.finish({}); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| await gc(); |
| let commandEncoder47 = device0.createCommandEncoder(); |
| let texture73 = device0.createTexture({ |
| size: {width: 3357, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder47 = commandEncoder43.beginComputePass({}); |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 67.98, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder45.setBindGroup(2, bindGroup12, new Uint32Array(4783), 2_314, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder45); computePassEncoder45.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| commandEncoder47.resolveQuerySet(querySet2, 19, 375, buffer19, 256); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 0, y: 119, z: 3}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(6).fill(230), /* required buffer size: 6 */ |
| {offset: 6}, {width: 256, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer1 = commandEncoder4.finish(); |
| let textureView56 = texture66.createView({baseArrayLayer: 3, arrayLayerCount: 2}); |
| let texture74 = device0.createTexture({ |
| size: {width: 839}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView57 = texture69.createView({}); |
| try { |
| commandEncoder47.copyBufferToBuffer(buffer16, 440, buffer9, 2416, 120); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 202, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView58 = texture73.createView({aspect: 'all', baseMipLevel: 0}); |
| let computePassEncoder48 = commandEncoder2.beginComputePass({}); |
| let sampler28 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 77.43}); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| computePassEncoder47.setPipeline(pipeline6); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 199, z: 22}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let buffer25 = device0.createBuffer({ |
| size: 5382, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let textureView59 = texture23.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| try { |
| computePassEncoder25.setBindGroup(3, bindGroup17, []); |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder47.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 51, y: 43, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 10, y: 32, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 32, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| document.body.append(img0); |
| let computePassEncoder49 = commandEncoder46.beginComputePass({label: '\u0d88\ua9ea\ub741\u94ab\u0c3c\u0754'}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup18, new Uint32Array(1526), 103, 1); |
| } catch {} |
| try { |
| adapter0.label = '\u8fe6\u{1f7e2}\u877b\ue884\u6e6c\u5f90\ue407\u0dca\u6a35\u98ae'; |
| } catch {} |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 59, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer26 = device0.createBuffer({ |
| size: 4065, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let texture75 = device0.createTexture({ |
| size: {width: 1, height: 273, depthOrArrayLayers: 27}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView60 = texture2.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let computePassEncoder50 = commandEncoder20.beginComputePass({}); |
| try { |
| computePassEncoder50.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| computePassEncoder22.insertDebugMarker('\u0989'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthStencilFormat: 'stencil8', sampleCount: 4}); |
| let renderBundle4 = renderBundleEncoder4.finish(); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 84.66, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup4, new Uint32Array(3308), 334, 1); |
| } catch {} |
| try { |
| computePassEncoder49.setPipeline(pipeline3); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 70, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder44.setBindGroup(2, bindGroup10, new Uint32Array(660), 74, 1); |
| } catch {} |
| try { |
| computePassEncoder48.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup20, [3072]); |
| } catch {} |
| try { |
| computePassEncoder43.setPipeline(pipeline3); |
| } catch {} |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'}); |
| try { |
| await buffer9.mapAsync(GPUMapMode.READ, 0, 5144); |
| } catch {} |
| try { |
| commandEncoder51.resolveQuerySet(querySet0, 99, 372, buffer17, 768); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let commandEncoder52 = device0.createCommandEncoder(); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthStencilFormat: 'stencil8', sampleCount: 4}); |
| let sampler30 = device0.createSampler({addressModeV: 'repeat', magFilter: 'linear', lodMaxClamp: 85.54}); |
| try { |
| computePassEncoder46.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup3, []); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 8, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 71, z: 16}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt709', transfer: 'gamma22curve'} }); |
| let bindGroup21 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer0, offset: 2048, size: 2324}}], |
| }); |
| let buffer27 = device0.createBuffer({ |
| size: 3449, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let sampler31 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 88.83, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder27.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer3, 'uint16', 226, 60); |
| } catch {} |
| try { |
| commandEncoder47.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 208 */ |
| offset: 208, |
| bytesPerRow: 54272, |
| buffer: buffer3, |
| }, { |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 0, y: 48, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 245, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder52.resolveQuerySet(querySet3, 17, 26, buffer15, 768); |
| } catch {} |
| try { |
| adapter0.label = '\udca4\u6820\u{1fc1f}\u{1f87c}\u1e30\u{1f6dc}\u5b3d\u{1f729}\u0b0c\u01ad\u022c'; |
| } catch {} |
| let sampler32 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 91.31}); |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(5, buffer17); |
| } catch {} |
| let pipeline7 = await promise2; |
| let commandBuffer2 = commandEncoder24.finish({}); |
| let computePassEncoder51 = commandEncoder47.beginComputePass(); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16sint'], |
| depthStencilFormat: 'stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let renderBundle5 = renderBundleEncoder6.finish({}); |
| try { |
| computePassEncoder37.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup16, new Uint32Array(537), 16, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer14, 'uint32', 156, 448); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| let computePassEncoder52 = commandEncoder50.beginComputePass({}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r16sint'], depthStencilFormat: 'stencil8', sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder52.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer22, 'uint32', 960, 768); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer21, 0, 22); |
| } catch {} |
| let recycledExplicitBindGroupLayout3 = pipeline1.getBindGroupLayout(0); |
| let computePassEncoder53 = commandEncoder48.beginComputePass({}); |
| try { |
| computePassEncoder44.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1692 */ |
| offset: 1692, |
| bytesPerRow: 52480, |
| buffer: buffer4, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 29, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder54 = commandEncoder52.beginComputePass({}); |
| try { |
| computePassEncoder51.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup2, new Uint32Array(153), 10, 0); |
| } catch {} |
| try { |
| device0.queue.label = '\u36a8\u0f4e\u{1fd49}\u143f\u0691\u58a2\u43d9'; |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer27, offset: 0, size: 2040}}], |
| }); |
| let texture76 = device0.createTexture({ |
| size: [4, 1575, 1], |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder55 = commandEncoder49.beginComputePass({}); |
| try { |
| computePassEncoder53.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 209, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 8, y: 12 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let textureView61 = texture69.createView({}); |
| let sampler33 = device0.createSampler({addressModeU: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 92.51}); |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup12, new Uint32Array(2342), 137, 0); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 716 */ |
| offset: 716, |
| bytesPerRow: 2048, |
| rowsPerImage: 796, |
| buffer: buffer4, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 0, y: 9, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let buffer28 = device0.createBuffer({ |
| label: '\ue5c4\u77fc\u2714\ue70b\u0051\u0520\u2bbd\u{1fe30}\uf2c4\ub2fd', |
| size: 23331, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture77 = device0.createTexture({ |
| size: [3357, 1, 1], |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView62 = texture50.createView({ |
| label: '\u{1fffe}\uab6b\ua06a\u221d\u{1fb72}\u{1f926}\uc3bd\u9b88\u{1f83e}', |
| dimension: 'cube-array', |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| let renderBundle6 = renderBundleEncoder5.finish({}); |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.47, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup1, new Uint32Array(1993), 97, 0); |
| } catch {} |
| try { |
| computePassEncoder48.end(); |
| } catch {} |
| try { |
| computePassEncoder54.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup11, []); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer22, 'uint32', 480, 2_200); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| adapter0.label = '\u0fbd\u{1ffe4}'; |
| } catch {} |
| let computePassEncoder56 = commandEncoder53.beginComputePass({}); |
| try { |
| computePassEncoder9.end(); |
| } catch {} |
| try { |
| computePassEncoder55.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup18, new Uint32Array(196), 56, 1); |
| } catch {} |
| try { |
| computePassEncoder43.insertDebugMarker('\u4ae0'); |
| } catch {} |
| let recycledExplicitBindGroupLayout4 = pipeline3.getBindGroupLayout(0); |
| try { |
| computePassEncoder56.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer19, 'uint32', 832, 17); |
| } catch {} |
| let buffer29 = device0.createBuffer({ |
| size: 3839, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture78 = device0.createTexture({ |
| size: [4, 1575, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup9, new Uint32Array(1208), 171, 1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer5, 'uint16', 202, 36); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(7, buffer7, 0); |
| } catch {} |
| try { |
| commandEncoder39.copyTextureToBuffer({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 6190 */ |
| offset: 6190, |
| bytesPerRow: 17408, |
| buffer: buffer23, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout5 = pipeline1.getBindGroupLayout(0); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let computePassEncoder57 = commandEncoder45.beginComputePass(); |
| let sampler35 = device0.createSampler({addressModeW: 'repeat', minFilter: 'linear', compare: 'always'}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup13, new Uint32Array(466), 175, 0); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| let commandBuffer3 = commandEncoder9.finish(); |
| let sampler36 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'linear', lodMaxClamp: 79.84}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup22, [512]); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer27, 'uint16', 528, 108); |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 495, resource: {buffer: buffer17, offset: 256, size: 1964}}, |
| {binding: 34, resource: textureView47}, |
| {binding: 28, resource: textureView42}, |
| {binding: 14, resource: sampler32}, |
| ], |
| }); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let textureView63 = texture47.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| commandEncoder39.copyTextureToTexture({ |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 1222, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 0, y: 58, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T1 { |
| @size(44) f0: array<u32>, |
| } |
| |
| /* used global variables: buffer30 */ |
| fn fn0() -> VertexOutput2 { |
| var out: VertexOutput2; |
| let vf23: vec3<bool> = (vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true)) != vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false))); |
| loop { |
| var vf24: vec4f = unpack4x8unorm(unconst_u32(7)); |
| let ptr15: ptr<storage, array<u32>, read> = &(*&buffer30).f0; |
| { |
| out.f3 = unpack4x8unorm((*&buffer30).f0[arrayLength(&(*&buffer30).f0)]); |
| break; |
| _ = buffer30; |
| } |
| var vf25: f16 = exp(f16(buffer30.f0[unconst_i32(-7)])); |
| var vf26: i32 = (unconst_i32(-19) - unconst_i32(306)); |
| vf26 *= vec4i(max(vec4f(unconst_f32(0.2014), unconst_f32(0.08161), unconst_f32(0.00686), unconst_f32(0.03156)), vec4f(unconst_f32(0.03737), unconst_f32(0.6352), unconst_f32(0.2518), unconst_f32(0.04265))))[2]; |
| break; |
| _ = buffer30; |
| } |
| let ptr16: ptr<storage, array<u32>, read> = &buffer30.f0; |
| var vf27: vec4h = exp2(vec4h(unconst_f16(8007.3), unconst_f16(1318.6), unconst_f16(16412.7), unconst_f16(29181.2))); |
| vf27 = vec4h(f16(select(bool(buffer30.f0[arrayLength(&buffer30.f0) - 1]), bool((*&buffer30).f0[arrayLength(&(*&buffer30).f0) - 1]), unconst_bool(false)))); |
| let vf28: u32 = arrayLength(&buffer30.f0); |
| vf27 = ceil(vec3h(unconst_f16(7016.4), unconst_f16(2899.2), unconst_f16(11145.3))).bbbr; |
| out = VertexOutput2(tan(vec3f(unconst_f32(-0.1362), unconst_f32(0.08804), unconst_f32(0.2267))).xyyy); |
| let vf29: i32 = firstTrailingBit(bitcast<i32>((*ptr16)[arrayLength(&(*ptr16))])); |
| vf27 = vec4h(f16(buffer30.f0[arrayLength(&buffer30.f0)])); |
| let vf30: f16 = step(unconst_f16(1169.2), unconst_f16(-2628.1)); |
| return out; |
| _ = buffer30; |
| } |
| |
| struct T0 { |
| @align(4) @size(44) f0: array<f16, 11>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: buffer30 */ |
| fn fn1() -> bool { |
| var out: bool; |
| let ptr17: ptr<storage, u32, read> = &buffer30.f0[unconst_u32(24)]; |
| fn0(); |
| fn0(); |
| let ptr18: ptr<storage, T1, read> = &buffer30; |
| fn0(); |
| out = bool((*ptr18).f0[arrayLength(&(*ptr18).f0)]); |
| if bool(countTrailingZeros(unconst_i32(4))) { |
| out = bool(extractBits(vec3i(unconst_i32(115), unconst_i32(-46), unconst_i32(821)), unconst_u32(20), unconst_u32(352))[2]); |
| let vf31: vec2f = unpack2x16float(unconst_u32(23)); |
| fn0(); |
| var vf32 = fn0(); |
| var vf33 = fn0(); |
| _ = buffer30; |
| } |
| { |
| fn0(); |
| out = bool(pow(vec4h(unconst_f16(20360.1), unconst_f16(2051.7), unconst_f16(11131.1), unconst_f16(3388.3)), vec4h(unconst_f16(10101.2), unconst_f16(-14034.2), unconst_f16(1008.9), unconst_f16(2177.5)))[1]); |
| while bool(arrayLength(&(*&buffer30).f0)) { |
| var vf34 = fn0(); |
| if bool(step(vec2f(unconst_f32(0.1301), unconst_f32(0.2189)), vec2f(unconst_f32(0.1092), unconst_f32(0.1368)))[0]) { |
| var vf35: bool = any(vec2<bool>(unconst_bool(false), unconst_bool(false))); |
| let ptr19: ptr<storage, u32, read> = &(*&buffer30).f0[unconst_u32(1)]; |
| _ = buffer30; |
| } |
| return out; |
| _ = buffer30; |
| } |
| _ = buffer30; |
| } |
| var vf36 = fn0(); |
| let ptr20: ptr<function, vec4f> = &vf36.f3; |
| var vf37 = fn0(); |
| var vf38 = fn0(); |
| return out; |
| _ = buffer30; |
| } |
| |
| @group(0) @binding(174) var<storage, read> buffer30: T1; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexOutput2 { |
| @invariant @builtin(position) f3: vec4f, |
| } |
| |
| /* used global variables: buffer30 */ |
| @vertex |
| fn vertex2() -> VertexOutput2 { |
| var out: VertexOutput2; |
| out = VertexOutput2(vec4f(bitcast<f32>(buffer30.f0[arrayLength(&buffer30.f0) - 1]))); |
| while bool(normalize(vec3h(unconst_f16(7113.0), unconst_f16(4260.1), unconst_f16(20666.3)))[1]) { |
| out.f3 = unpack4x8unorm((*&buffer30).f0[arrayLength(&(*&buffer30).f0)]); |
| break; |
| _ = buffer30; |
| } |
| out.f3 = unpack4x8snorm((*&buffer30).f0[arrayLength(&(*&buffer30).f0)]); |
| var vf39: f16 = sqrt(unconst_f16(-34025.2)); |
| return out; |
| _ = buffer30; |
| } |
| |
| /* used global variables: buffer30 */ |
| @fragment |
| fn fragment1() -> @location(200) @interpolate(flat) vec4u { |
| var out: vec4u; |
| out = vec4u(buffer30.f0[arrayLength(&buffer30.f0)]); |
| let vf40: vec2<bool> = (vec2h(unconst_f16(7315.4), unconst_f16(41030.9)) < vec2h(unconst_f16(3198.9), unconst_f16(1956.0))); |
| var vf41: u32 = pack4x8unorm(vec4f(unconst_f32(-0.5165), unconst_f32(0.07544), unconst_f32(0.01253), unconst_f32(0.2863))); |
| vf41 -= (*&buffer30).f0[(*&buffer30).f0[arrayLength(&(*&buffer30).f0)]]; |
| var vf42: i32 = dot4I8Packed(unconst_u32(27), unconst_u32(71)); |
| var vf43: vec2f = unpack2x16snorm(u32(all((vec4u(unconst_u32(60), unconst_u32(7), unconst_u32(328), unconst_u32(58)) <= vec4u(unconst_u32(300), unconst_u32(190), unconst_u32(384), unconst_u32(736)))))); |
| vf42 |= i32((*&buffer30).f0[arrayLength(&(*&buffer30).f0)]); |
| out = vec4u((vec2f(unconst_f32(-0.09618), unconst_f32(0.04256)) <= vec2f(unconst_f32(0.2185), unconst_f32(0.1012))).grgg); |
| return out; |
| _ = buffer30; |
| } |
| |
| /* used global variables: buffer30 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute3() { |
| let vf44: u32 = arrayLength(&(*&buffer30).f0); |
| _ = buffer30; |
| }`, |
| }); |
| let buffer31 = device0.createBuffer({ |
| size: 1458, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let renderBundle7 = renderBundleEncoder7.finish({}); |
| let sampler37 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', addressModeW: 'repeat'}); |
| try { |
| computePassEncoder57.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder54.copyBufferToTexture({ |
| /* bytesInLastRow: 2784 widthInBlocks: 1392 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1890 */ |
| offset: 1890, |
| bytesPerRow: 14592, |
| buffer: buffer21, |
| }, { |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1392, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let computePassEncoder58 = commandEncoder39.beginComputePass({}); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| commandEncoder55.copyBufferToBuffer(buffer19, 1360, buffer17, 468, 960); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 59, resource: textureView20}]}); |
| let commandBuffer4 = commandEncoder2.finish({}); |
| let computePassEncoder59 = commandEncoder55.beginComputePass({}); |
| let sampler38 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup22, new Uint32Array(2449), 1_799, 1); |
| } catch {} |
| try { |
| commandEncoder54.copyBufferToBuffer(buffer3, 120, buffer1, 6496, 556); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup25 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 34, resource: textureView47}, |
| {binding: 28, resource: textureView42}, |
| {binding: 495, resource: {buffer: buffer31, offset: 0, size: 760}}, |
| {binding: 14, resource: sampler16}, |
| ], |
| }); |
| let buffer32 = device0.createBuffer({size: 8178, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder57 = device0.createCommandEncoder({label: '\u4a3e\uc83b\u01bb\u{1fc6d}\u{1f97d}\uc1fd\u7540\u5921'}); |
| let texture79 = device0.createTexture({size: [1, 273, 1], format: 'stencil8', usage: GPUTextureUsage.COPY_DST, viewFormats: ['stencil8']}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup7, [256]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer11, 600); }; |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let promise7 = shaderModule3.getCompilationInfo(); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let arrayBuffer2 = buffer9.getMappedRange(0, 1644); |
| try { |
| computePassEncoder57.insertDebugMarker('\u06cb'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| let videoFrame7 = new VideoFrame(videoFrame3, {timestamp: 0}); |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout4]}); |
| let textureView64 = texture12.createView({aspect: 'all'}); |
| let computePassEncoder60 = commandEncoder57.beginComputePass({}); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder60.setPipeline(pipeline6); |
| } catch {} |
| try { |
| buffer27.unmap(); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({layout: pipelineLayout4, compute: {module: shaderModule1, constants: {}}}); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let sampler39 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 34.59, |
| lodMaxClamp: 96.26, |
| maxAnisotropy: 6, |
| }); |
| try { |
| commandEncoder51.copyTextureToBuffer({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 266, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 728 widthInBlocks: 91 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 3120 */ |
| offset: 3120, |
| buffer: buffer8, |
| }, {width: 91, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(videoFrame3); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let texture80 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder61 = commandEncoder58.beginComputePass({}); |
| try { |
| computePassEncoder52.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder61.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToTexture({ |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 195, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 91, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 70, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup26 = device0.createBindGroup({ |
| label: '\u{1f7d6}\u0ea9\u{1f916}\u{1fb52}\u0abb\u0c4e\u{1f74a}\u{1fd38}\u4071\u08be', |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 70, resource: {buffer: buffer29, offset: 256, size: 973}}, |
| {binding: 116, resource: {buffer: buffer0, offset: 1536, size: 5420}}, |
| ], |
| }); |
| let buffer33 = device0.createBuffer({size: 21714, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder60 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup4, new Uint32Array(936), 278, 1); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1968 */ |
| offset: 1968, |
| bytesPerRow: 13568, |
| rowsPerImage: 770, |
| buffer: buffer16, |
| }, { |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 0, y: 177, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 215, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let computePassEncoder62 = commandEncoder61.beginComputePass(); |
| let sampler40 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', mipmapFilter: 'nearest'}); |
| try { |
| computePassEncoder46.setBindGroup(0, bindGroup7, new Uint32Array(4094), 52, 1); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToBuffer({ |
| texture: texture63, |
| mipLevel: 1, |
| origin: {x: 0, y: 48, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 436 */ |
| offset: 436, |
| bytesPerRow: 5120, |
| buffer: buffer21, |
| }, {width: 0, height: 197, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 0, y: 24, z: 2}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(37).fill(182), /* required buffer size: 37 */ |
| {offset: 37}, {width: 256, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup27 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [{binding: 174, resource: {buffer: buffer31, offset: 0, size: 208}}], |
| }); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let textureView65 = texture8.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let sampler41 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| maxAnisotropy: 1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer21, 3_000); }; |
| } catch {} |
| try { |
| commandEncoder62.copyBufferToBuffer(buffer3, 568, buffer25, 640, 332); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(226).fill(244), /* required buffer size: 226 */ |
| {offset: 226}, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline9 = device0.createRenderPipeline({ |
| layout: pipelineLayout3, |
| multisample: {mask: 0x21fc3b4}, |
| fragment: { |
| module: shaderModule3, |
| targets: [{format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [{arrayStride: 124, attributes: [{format: 'float32x4', offset: 0, shaderLocation: 8}]}], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: false}, |
| }); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup28 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer28, offset: 8192, size: 5412}}, |
| {binding: 70, resource: {buffer: buffer28, offset: 2048, size: 5041}}, |
| ], |
| }); |
| let textureView66 = texture12.createView({format: 'r16sint'}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder37.setBindGroup(3, bindGroup10, [1792]); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup14, new Uint32Array(834), 353, 1); |
| } catch {} |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| commandEncoder62.copyTextureToBuffer({ |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 0, y: 30, z: 0}, |
| aspect: 'stencil-only', |
| }, { |
| /* bytesInLastRow: 2 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 4700 */ |
| offset: 4700, |
| bytesPerRow: 28160, |
| buffer: buffer3, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame8 = new VideoFrame(videoFrame3, {timestamp: 0}); |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let texture81 = device0.createTexture({ |
| size: {width: 2, height: 787, depthOrArrayLayers: 67}, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder63 = commandEncoder54.beginComputePass({}); |
| let sampler42 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMinClamp: 30.33, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| commandEncoder60.copyBufferToTexture({ |
| /* bytesInLastRow: 204 widthInBlocks: 102 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 188 */ |
| offset: 188, |
| buffer: buffer14, |
| }, { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 135, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 102, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [{binding: 174, resource: {buffer: buffer3, offset: 0, size: 572}}], |
| }); |
| let textureView67 = texture81.createView({}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup15, [1024]); |
| } catch {} |
| try { |
| computePassEncoder63.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToTexture({ |
| texture: texture19, |
| mipLevel: 1, |
| origin: {x: 0, y: 36, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup30 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 28, resource: textureView42}, |
| {binding: 34, resource: textureView47}, |
| {binding: 14, resource: sampler39}, |
| {binding: 495, resource: {buffer: buffer0, offset: 256, size: 1292}}, |
| ], |
| }); |
| let buffer34 = device0.createBuffer({ |
| size: 16002, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let textureView68 = texture66.createView({dimension: '2d', baseArrayLayer: 1}); |
| let texture82 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| commandEncoder64.copyBufferToTexture({ |
| /* bytesInLastRow: 118 widthInBlocks: 59 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5018 */ |
| offset: 5018, |
| bytesPerRow: 4096, |
| buffer: buffer34, |
| }, { |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 121, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 59, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 1044, new Float32Array(6672), 4159, 96); |
| } catch {} |
| document.body.prepend(img0); |
| let texture83 = device0.createTexture({ |
| size: [3357], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup21, new Uint32Array(132), 27, 1); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1388 */ |
| offset: 1388, |
| buffer: buffer4, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder1.copyTextureToBuffer({ |
| texture: texture5, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, { |
| /* bytesInLastRow: 13 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1949 */ |
| offset: 1936, |
| buffer: buffer21, |
| }, {width: 13, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder62.clearBuffer(buffer0, 2620, 4516); |
| } catch {} |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let buffer35 = device0.createBuffer({ |
| size: 25919, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandBuffer5 = commandEncoder1.finish(); |
| let texture84 = device0.createTexture({ |
| size: [839], |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder64 = commandEncoder59.beginComputePass({}); |
| try { |
| computePassEncoder62.setBindGroup(0, bindGroup4, new Uint32Array(88), 12, 1); |
| } catch {} |
| try { |
| computePassEncoder0.end(); |
| } catch {} |
| try { |
| computePassEncoder64.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder12.pushDebugGroup('\uabf6'); |
| } catch {} |
| try { |
| computePassEncoder12.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 5, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup31 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer17, offset: 256, size: 240}}], |
| }); |
| let commandEncoder65 = device0.createCommandEncoder(); |
| let texture85 = device0.createTexture({ |
| size: [1, 136, 1], |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture86 = device0.createTexture({ |
| size: [256, 256, 21], |
| mipLevelCount: 3, |
| format: 'stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView69 = texture3.createView({format: 'r32sint', arrayLayerCount: 1}); |
| let computePassEncoder65 = commandEncoder63.beginComputePass({}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup24, new Uint32Array(3683), 148, 0); |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline5); |
| } 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 { |
| commandEncoder0.clearBuffer(buffer25, 120, 124); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 12, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 70, resource: {buffer: buffer11, offset: 768, size: 923}}, |
| {binding: 116, resource: {buffer: buffer25, offset: 0, size: 4232}}, |
| ], |
| }); |
| let buffer36 = device0.createBuffer({size: 4499, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let textureView70 = texture83.createView({baseMipLevel: 0}); |
| let computePassEncoder66 = commandEncoder62.beginComputePass({}); |
| let sampler43 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 66.01, compare: 'always'}); |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup10, [1280]); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToBuffer(buffer21, 5916, buffer24, 232, 220); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 62, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline10 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x4edf9309}, |
| fragment: { |
| module: shaderModule1, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'equal', failOp: 'replace', depthFailOp: 'zero', passOp: 'zero'}, |
| stencilBack: {compare: 'less-equal', failOp: 'increment-clamp', depthFailOp: 'increment-wrap', passOp: 'invert'}, |
| stencilReadMask: 493572131, |
| stencilWriteMask: 355281851, |
| depthBias: -936575024, |
| depthBiasClamp: 117.35366950391324, |
| }, |
| vertex: {module: shaderModule3, buffers: []}, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', cullMode: 'none'}, |
| }); |
| let imageData4 = new ImageData(256, 28); |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt470m', transfer: 'gamma22curve'} }); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let computePassEncoder67 = commandEncoder60.beginComputePass({}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup21, [5888]); |
| } catch {} |
| try { |
| computePassEncoder66.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer25, offset: 2304, size: 528}}], |
| }); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let texture87 = device0.createTexture({ |
| size: {width: 1678, height: 1, depthOrArrayLayers: 235}, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let sampler44 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 80.77, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder60.setBindGroup(0, bindGroup29, new Uint32Array(2470), 21, 1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 173, z: 11}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 270}); |
| let texture88 = device0.createTexture({ |
| size: {width: 1678, height: 1, depthOrArrayLayers: 13}, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder68 = commandEncoder69.beginComputePass({}); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let arrayBuffer3 = buffer9.getMappedRange(1648, 464); |
| try { |
| buffer34.unmap(); |
| } catch {} |
| try { |
| commandEncoder67.copyBufferToTexture({ |
| /* bytesInLastRow: 192 widthInBlocks: 96 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5682 */ |
| offset: 5682, |
| buffer: buffer14, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 48, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 96, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup34 = device0.createBindGroup({layout: veryExplicitBindGroupLayout4, entries: [{binding: 360, resource: textureView21}]}); |
| let texture89 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler45 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 97.50}); |
| let commandEncoder70 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder53.setBindGroup(2, bindGroup8, new Uint32Array(2236), 392, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder64); computePassEncoder64.dispatchWorkgroupsIndirect(buffer22, 440); }; |
| } catch {} |
| try { |
| computePassEncoder32.end(); |
| } catch {} |
| let pipeline11 = await promise4; |
| let textureView71 = texture17.createView({mipLevelCount: 1}); |
| let texture90 = device0.createTexture({ |
| size: [256, 256, 21], |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup31, new Uint32Array(1857), 861, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer4, 1_072); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 264, new Int16Array(6189), 1087, 736); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 347, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(73).fill(141), /* required buffer size: 73 */ |
| {offset: 73, bytesPerRow: 1579}, {width: 766, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 87, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout0]}); |
| let texture91 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView72 = texture20.createView({}); |
| let computePassEncoder69 = commandEncoder70.beginComputePass({}); |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| computePassEncoder68.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture67, |
| mipLevel: 1, |
| origin: {x: 9, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(73_918).fill(132), /* required buffer size: 73_918 */ |
| {offset: 13, bytesPerRow: 379, rowsPerImage: 39}, {width: 172, height: 0, depthOrArrayLayers: 6}); |
| } catch {} |
| let buffer37 = device0.createBuffer({size: 14279, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let texture92 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView73 = texture66.createView({format: 'rgba16float', mipLevelCount: 1, arrayLayerCount: 4}); |
| let computePassEncoder70 = commandEncoder64.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder46); computePassEncoder46.dispatchWorkgroupsIndirect(buffer22, 240); }; |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 0, y: 32, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(273).fill(12), /* required buffer size: 273 */ |
| {offset: 273}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let textureView74 = texture41.createView({format: 'r16sint'}); |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup20, new Uint32Array(1027), 151, 1); |
| } catch {} |
| try { |
| commandEncoder0.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 912 */ |
| offset: 912, |
| bytesPerRow: 4352, |
| rowsPerImage: 568, |
| buffer: buffer35, |
| }, { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 0, y: 40, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 160, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer17, 828, new BigUint64Array(49068), 1848, 372); |
| } catch {} |
| await gc(); |
| let recycledExplicitBindGroupLayout6 = pipeline8.getBindGroupLayout(0); |
| let computePassEncoder71 = commandEncoder65.beginComputePass(); |
| let sampler46 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 56.86, |
| maxAnisotropy: 2, |
| }); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup25, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer11, 8); }; |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let textureView75 = texture83.createView({dimension: '1d', format: 'rgba32float'}); |
| let computePassEncoder72 = commandEncoder56.beginComputePass(); |
| try { |
| computePassEncoder67.setBindGroup(0, bindGroup2, new Uint32Array(4114), 771, 0); |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToTexture({ |
| /* bytesInLastRow: 436 widthInBlocks: 109 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 928 */ |
| offset: 928, |
| buffer: buffer23, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 132, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 109, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline12 = await device0.createComputePipelineAsync({layout: pipelineLayout6, compute: {module: shaderModule1}}); |
| let buffer38 = device0.createBuffer({size: 5664, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture93 = device0.createTexture({ |
| size: {width: 1, height: 547, depthOrArrayLayers: 304}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder73 = commandEncoder71.beginComputePass({}); |
| let sampler47 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 92.03}); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder70.setBindGroup(1, bindGroup33, new Uint32Array(347), 13, 1); |
| } catch {} |
| try { |
| computePassEncoder70.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer5, 196, buffer33, 608, 136); |
| } catch {} |
| try { |
| commandEncoder67.copyBufferToTexture({ |
| /* bytesInLastRow: 144 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1512 */ |
| offset: 1512, |
| buffer: buffer23, |
| }, { |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer39 = device0.createBuffer({ |
| size: 4651, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture94 = device0.createTexture({ |
| size: [1, 547, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder74 = commandEncoder31.beginComputePass({}); |
| let sampler48 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', mipmapFilter: 'linear'}); |
| try { |
| computePassEncoder71.setPipeline(pipeline3); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let imageData5 = new ImageData(20, 44); |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let querySet6 = device0.createQuerySet({type: 'occlusion', count: 65}); |
| let computePassEncoder75 = commandEncoder51.beginComputePass({}); |
| let sampler49 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', minFilter: 'linear'}); |
| try { |
| computePassEncoder72.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder66.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 470 */ |
| offset: 470, |
| bytesPerRow: 19968, |
| rowsPerImage: 251, |
| buffer: buffer16, |
| }, { |
| texture: texture19, |
| mipLevel: 2, |
| origin: {x: 0, y: 7, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(528).fill(39), /* required buffer size: 528 */ |
| {offset: 528, bytesPerRow: 32}, {width: 1, height: 273, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let bindGroup35 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 202, resource: textureView71}, {binding: 47, resource: textureView8}], |
| }); |
| let texture95 = device0.createTexture({size: [1678, 1, 15], mipLevelCount: 5, format: 'rg11b10ufloat', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup32, [768]); |
| } catch {} |
| try { |
| commandEncoder67.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 86 */ |
| offset: 86, |
| buffer: buffer14, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder0.resolveQuerySet(querySet0, 383, 36, buffer22, 1280); |
| } catch {} |
| let textureView76 = texture84.createView({}); |
| let sampler50 = device0.createSampler({addressModeU: 'repeat', magFilter: 'linear', minFilter: 'linear'}); |
| try { |
| computePassEncoder65.setPipeline(pipeline5); |
| } catch {} |
| let commandEncoder74 = device0.createCommandEncoder(); |
| let computePassEncoder76 = commandEncoder68.beginComputePass(); |
| let sampler51 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup31, new Uint32Array(1780), 1_446, 1); |
| } catch {} |
| try { |
| computePassEncoder45.end(); |
| } catch {} |
| let imageData6 = new ImageData(88, 20); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer14, offset: 1792, size: 120}}], |
| }); |
| try { |
| computePassEncoder39.setBindGroup(0, bindGroup31, new Uint32Array(1812), 11, 1); |
| } catch {} |
| try { |
| computePassEncoder46.end(); |
| } catch {} |
| let arrayBuffer4 = buffer1.getMappedRange(408, 124); |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| commandEncoder0.copyTextureToBuffer({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 44 */ |
| offset: 44, |
| bytesPerRow: 56064, |
| buffer: buffer18, |
| }, {width: 0, height: 225, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder75 = device0.createCommandEncoder(); |
| let commandBuffer6 = commandEncoder42.finish(); |
| let textureView77 = texture3.createView({dimension: '2d', baseArrayLayer: 13}); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder67.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 2336 */ |
| offset: 2336, |
| bytesPerRow: 4352, |
| buffer: buffer16, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 147, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| try { |
| adapter0.label = '\u89bb\u590f\u0516\u0b5f\ueebe\u1583\ucffd\u1ad9\u0f8f\u4d8f\uddd8'; |
| } catch {} |
| let buffer40 = device0.createBuffer({ |
| size: 4910, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let computePassEncoder77 = commandEncoder0.beginComputePass(); |
| try { |
| computePassEncoder74.setPipeline(pipeline12); |
| } catch {} |
| try { |
| commandEncoder72.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 128 */ |
| offset: 128, |
| buffer: buffer40, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 2, |
| origin: {x: 0, y: 18, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(152).fill(220), /* required buffer size: 152 */ |
| {offset: 152, bytesPerRow: 40}, {width: 0, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 171} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 45, z: 30}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture96 = device0.createTexture({ |
| size: {width: 4, height: 1575, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler52 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder76.setPipeline(pipeline5); |
| } catch {} |
| let pipeline13 = device0.createRenderPipeline({ |
| layout: pipelineLayout6, |
| multisample: {count: 4}, |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'not-equal', failOp: 'decrement-wrap', depthFailOp: 'increment-wrap', passOp: 'zero'}, |
| stencilBack: { |
| compare: 'greater', |
| failOp: 'increment-clamp', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'increment-clamp', |
| }, |
| stencilWriteMask: 184769459, |
| }, |
| vertex: { |
| module: shaderModule2, |
| buffers: [ |
| { |
| arrayStride: 1764, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x2', offset: 302, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 192, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 216, shaderLocation: 2}, |
| {format: 'unorm16x2', offset: 724, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'front', unclippedDepth: false}, |
| }); |
| let recycledExplicitBindGroupLayout7 = pipeline13.getBindGroupLayout(0); |
| let commandBuffer7 = commandEncoder44.finish(); |
| let textureView78 = texture56.createView({dimension: 'cube-array', format: 'stencil8', baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup21, new Uint32Array(1342), 48, 1); |
| } catch {} |
| try { |
| computePassEncoder52.end(); |
| } catch {} |
| try { |
| computePassEncoder77.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder75.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1192 */ |
| offset: 1192, |
| bytesPerRow: 22784, |
| buffer: buffer14, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder74.copyTextureToBuffer({ |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 0, y: 84, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1060 */ |
| offset: 1060, |
| bytesPerRow: 12288, |
| buffer: buffer17, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder64.pushDebugGroup('\uf5ce'); |
| } catch {} |
| try { |
| computePassEncoder64.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7]); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise10; |
| } catch {} |
| offscreenCanvas0.width = 1971; |
| let buffer41 = device0.createBuffer({size: 8684, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let texture97 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder78 = commandEncoder74.beginComputePass({}); |
| try { |
| computePassEncoder77.setBindGroup(0, bindGroup21, [2304]); |
| } catch {} |
| try { |
| computePassEncoder37.setBindGroup(3, bindGroup7, new Uint32Array(556), 169, 1); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer6]); |
| } catch {} |
| try { |
| adapter0.label = '\u0df1\u{1fe95}\ud010\u140b\u0c98\u6885\u{1fca9}'; |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let texture98 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 6, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler53 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 74.08, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup8, new Uint32Array(761), 261, 0); |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder76.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1232 */ |
| offset: 1232, |
| bytesPerRow: 6144, |
| buffer: buffer22, |
| }, { |
| texture: texture75, |
| mipLevel: 2, |
| origin: {x: 0, y: 5, z: 1}, |
| aspect: 'all', |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 912, new Int16Array(12660), 3952, 1292); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture58, |
| mipLevel: 4, |
| origin: {x: 0, y: 8, z: 3}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(3).fill(48), /* required buffer size: 3 */ |
| {offset: 3}, {width: 16, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| try { |
| commandEncoder78.resolveQuerySet(querySet3, 120, 63, buffer14, 256); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder78.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder77.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 60 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1978 */ |
| offset: 1978, |
| buffer: buffer29, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 60, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder79 = commandEncoder77.beginComputePass({}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup19, [1024]); |
| } catch {} |
| let promise12 = shaderModule2.getCompilationInfo(); |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| commandEncoder72.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 772 */ |
| offset: 772, |
| bytesPerRow: 5632, |
| rowsPerImage: 1143, |
| buffer: buffer3, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 273, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 209, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 8, y: 7 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 36, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let texture99 = device0.createTexture({ |
| size: [1, 196, 1], |
| format: 'stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder80 = commandEncoder79.beginComputePass({}); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup28, new Uint32Array(726), 192, 1); |
| } catch {} |
| let arrayBuffer5 = buffer1.getMappedRange(600, 80); |
| let bindGroup37 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 432, resource: textureView42}, {binding: 77, resource: textureView58}], |
| }); |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| let querySet7 = device0.createQuerySet({type: 'occlusion', count: 303}); |
| try { |
| commandEncoder76.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 710 */ |
| offset: 710, |
| bytesPerRow: 17152, |
| buffer: buffer23, |
| }, { |
| texture: texture49, |
| mipLevel: 2, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(48).fill(17), /* required buffer size: 48 */ |
| {offset: 48, rowsPerImage: 30}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer42 = device0.createBuffer({ |
| size: 17912, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let querySet8 = device0.createQuerySet({type: 'occlusion', count: 953}); |
| let textureView79 = texture81.createView({mipLevelCount: 1}); |
| let computePassEncoder81 = commandEncoder11.beginComputePass(); |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder81.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let texture100 = device0.createTexture({size: [839, 1, 54], format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, viewFormats: []}); |
| let textureView80 = texture88.createView({baseArrayLayer: 3, arrayLayerCount: 3}); |
| try { |
| computePassEncoder79.setPipeline(pipeline11); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({ |
| label: '\u4572\u09d4\u5fbf\u{1f742}\u{1ff12}', |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 87, resource: {buffer: buffer11, offset: 0, size: 1480}}], |
| }); |
| let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4]}); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture101 = device0.createTexture({ |
| size: {width: 4}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView81 = texture35.createView({dimension: '2d-array', aspect: 'all'}); |
| let computePassEncoder82 = commandEncoder67.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder64.end(); |
| } catch {} |
| try { |
| computePassEncoder82.setPipeline(pipeline12); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1384 */ |
| offset: 1384, |
| rowsPerImage: 426, |
| buffer: buffer40, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 0, y: 38, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView82 = texture48.createView({label: '\u0081\u{1fc2e}\u89c7\u7d17', aspect: 'stencil-only', baseArrayLayer: 0}); |
| try { |
| computePassEncoder68.setBindGroup(2, bindGroup23, new Uint32Array(1350), 396, 0); |
| } catch {} |
| try { |
| commandEncoder78.copyBufferToBuffer(buffer34, 568, buffer16, 272, 20); |
| } catch {} |
| try { |
| commandEncoder50.clearBuffer(buffer33, 1456, 6064); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| enable f16; |
| |
| var<private> vp9: array<FragmentOutput1, 1> = array(FragmentOutput1()); |
| |
| /* used global variables: buffer43 */ |
| fn fn1(a0: ptr<storage, array<u32>, read_write>) { |
| for (var it2=u32(buffer43[u32((*&buffer43)[arrayLength(&(*&buffer43))][10])][vp9[0].f2]); it2<u32(vp9[0].f1[unconst_u32(90)]); it2++) { |
| let vf46: f32 = override2; |
| var vf47: i32 = vp9[unconst_u32(271)].f0[unconst_u32(22)]; |
| _ = override2; |
| } |
| let ptr26: ptr<storage, array<i32, 11>, read> = &(*&buffer43)[unconst_i32(21)]; |
| vp9[(*a0)[arrayLength(&(*a0))]].f2 = bitcast<vec4u>(vp9[0].f0)[2]; |
| vp8 = VertexOutput3(vp8.f4, vec2h(vp8.f4.gr), bitcast<vec4f>(vp8.f4)); |
| switch bitcast<vec4i>(vp9[0].f1)[2] { |
| default { |
| vp9[unconst_u32(14)] = FragmentOutput1(unpack4xI8(u32(insertBits(vec3i(unconst_i32(34), unconst_i32(17), unconst_i32(61)), vec3i(unconst_i32(475), unconst_i32(0), unconst_i32(221)), unconst_u32(193), unconst_u32(282)).g)), bitcast<vec4f>(unpack4xI8(u32(insertBits(vec3i(unconst_i32(34), unconst_i32(17), unconst_i32(61)), vec3i(unconst_i32(475), unconst_i32(0), unconst_i32(221)), unconst_u32(193), unconst_u32(282)).g))), pack4xI8Clamp(unpack4xI8(u32(insertBits(vec3i(unconst_i32(34), unconst_i32(17), unconst_i32(61)), vec3i(unconst_i32(475), unconst_i32(0), unconst_i32(221)), unconst_u32(193), unconst_u32(282)).g)))); |
| (*a0)[unconst_u32(71)] -= bitcast<u32>((*&buffer43)[unconst_u32(212)][10]); |
| return; |
| _ = buffer43; |
| } |
| } |
| _ = override2; |
| _ = buffer43; |
| } |
| |
| @group(0) @binding(174) var<storage, read> buffer43: array<array<i32, 11>>; |
| |
| struct VertexOutput3 { |
| @location(2) f4: vec4u, |
| @location(8) f5: vec2h, |
| @builtin(position) f6: vec4f, |
| } |
| |
| @id(29444) override override4: f16; |
| |
| @id(29957) override override3: f16; |
| |
| struct FragmentOutput1 { |
| @location(2) f0: vec4i, |
| @location(0) f1: vec4f, |
| @builtin(sample_mask) f2: u32, |
| } |
| |
| struct S0 { |
| @location(10) @interpolate(flat) f0: vec2u, |
| @builtin(instance_index) f1: u32, |
| } |
| |
| @id(54727) override override0: u32 = 135; |
| |
| struct T0 { |
| @size(76) f0: array<array<u32, 1>, 1>, |
| } |
| |
| @id(35987) override override2 = 0.00472; |
| |
| override override5: f32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp8: VertexOutput3 = VertexOutput3(); |
| |
| @id(34762) override override1: u32; |
| |
| /* used global variables: buffer43 */ |
| fn fn0(a0: ptr<storage, array<u32>, read_write>, a1: VertexOutput3, a2: ptr<storage, array<u32>, read_write>, a3: ptr<function, FragmentOutput1>) -> array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1> { |
| var out: array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 1>; |
| while bool(a1.f6.y) { |
| out[unconst_u32(640)][unconst_u32(23)][unconst_u32(70)][unconst_u32(786)][unconst_u32(336)] -= f16(arrayLength(&(*a0))); |
| var vf45: vec2h = a1.f5; |
| let ptr21: ptr<storage, array<i32, 11>, read> = &(*&buffer43)[u32((*&buffer43)[arrayLength(&(*&buffer43))][10])]; |
| break; |
| _ = buffer43; |
| } |
| let ptr22: ptr<private, vec2h> = &vp8.f5; |
| let ptr23: ptr<private, vec4i> = &vp9[0].f0; |
| let ptr24: ptr<storage, i32, read> = &buffer43[arrayLength(&buffer43)][unconst_u32(41)]; |
| let ptr25: ptr<storage, array<i32, 11>, read> = &buffer43[unconst_u32(179)]; |
| return out; |
| _ = buffer43; |
| } |
| |
| var<workgroup> vw7: vec4h; |
| |
| struct VertexOutput4 { |
| @builtin(position) f7: vec4f, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<private> vp10: mat4x3h = mat4x3h(7458.6, 6555.6, -24913.0, 9472.4, 675.0, 5812.3, 3911.0, -4190.4, 6157.4, 8217.6, -227.7, 2623.8); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex3(@location(3) a0: vec4h, @location(1) a1: vec2h, a2: S0) -> VertexOutput3 { |
| var out: VertexOutput3; |
| return out; |
| } |
| |
| /* used global variables: buffer43 */ |
| @vertex |
| fn vertex4() -> VertexOutput4 { |
| var out: VertexOutput4; |
| let ptr27: ptr<storage, i32, read> = &buffer43[unconst_u32(84)][10]; |
| let ptr28: ptr<private, vec4u> = &vp8.f4; |
| while bool((*&buffer43)[arrayLength(&(*&buffer43))][pack4x8snorm(vp9[0].f1)]) { |
| } |
| out.f7 += vec4f(unpack4xU8(unconst_u32(868))); |
| out.f7 -= (vec4f(f32(buffer43[arrayLength(&buffer43)][unconst_u32(187)])) - vec4f(f32(atan2(unconst_f16(5794.3), unconst_f16(11159.8))))); |
| var vf48: u32 = override0; |
| while bool((*ptr28).w) { |
| switch bitcast<vec3i>(step(vec3f(unconst_f32(0.03976), unconst_f32(0.01375), unconst_f32(0.02441)), vec3f(unconst_f32(0.1538), unconst_f32(0.1482), unconst_f32(0.05061)))).x { |
| default { |
| vp9[unconst_u32(176)] = FragmentOutput1(vec4i(buffer43[unconst_u32(396)][10]), vec4f(f32(buffer43[unconst_u32(396)][10])), bitcast<u32>(buffer43[unconst_u32(396)][10])); |
| out = VertexOutput4(vec4f(bitcast<f32>((*&buffer43)[unconst_u32(65)][10]))); |
| return out; |
| _ = buffer43; |
| } |
| } |
| var vf49: vec4i = countLeadingZeros(vec4i(unconst_i32(39), unconst_i32(-86), unconst_i32(296), unconst_i32(167))); |
| let vf50: u32 = dot4U8Packed(unconst_u32(169), unconst_u32(345)); |
| let ptr29: ptr<private, vec4i> = &vp9[unconst_u32(332)].f0; |
| let ptr30: ptr<storage, array<i32, 11>, read> = &buffer43[arrayLength(&buffer43) - 1]; |
| var vf51: u32 = pack4x8unorm(vec4f(unconst_f32(0.4609), unconst_f32(0.06373), unconst_f32(0.08707), unconst_f32(0.2759))); |
| out.f7 *= vp9[unconst_u32(43)].f1; |
| break; |
| _ = buffer43; |
| } |
| return out; |
| _ = override0; |
| _ = buffer43; |
| } |
| |
| /* used global variables: buffer43 */ |
| @fragment |
| fn fragment2() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| vp9[unconst_u32(75)].f1 += vec4f(radians(unconst_f32(0.3626))); |
| out.f2 = pack4x8snorm(unpack4x8unorm(unconst_u32(122))); |
| let vf52: u32 = pack4x8unorm(vec4f(unconst_f32(0.05390), unconst_f32(0.3858), unconst_f32(0.03348), unconst_f32(0.1370))); |
| while bool(extractBits(bitcast<vec3u>(sinh(vec2f(unconst_f32(-0.06815), unconst_f32(0.1094))).ggr), unconst_u32(217), unconst_u32(136)).b) { |
| break; |
| } |
| let ptr31: ptr<storage, i32, read> = &(*&buffer43)[unconst_u32(39)][unconst_u32(219)]; |
| var vf53: vec3u = extractBits(vec3u(u32(sign(unconst_f16(-19737.6)))), unconst_u32(88), unconst_u32(384)); |
| let ptr32: ptr<private, vec4i> = &vp9[0].f0; |
| let ptr33: ptr<private, vec4i> = &vp9[0].f0; |
| let ptr34: ptr<private, vec4i> = &(*ptr32); |
| return out; |
| _ = buffer43; |
| } |
| |
| /* used global variables: buffer43 */ |
| @fragment |
| fn fragment3() -> @location(200) vec4f { |
| var out: vec4f; |
| vp9[unconst_u32(60)] = FragmentOutput1(vec4i(refract(vec4h(unconst_f16(471.6), unconst_f16(-8812.2), unconst_f16(2945.5), unconst_f16(11743.3)), vec4h(unconst_f16(1256.0), unconst_f16(2257.9), unconst_f16(15183.0), unconst_f16(1240.8)), unconst_f16(10464.2))), vec4f(refract(vec4h(unconst_f16(471.6), unconst_f16(-8812.2), unconst_f16(2945.5), unconst_f16(11743.3)), vec4h(unconst_f16(1256.0), unconst_f16(2257.9), unconst_f16(15183.0), unconst_f16(1240.8)), unconst_f16(10464.2))), vec4u(refract(vec4h(unconst_f16(471.6), unconst_f16(-8812.2), unconst_f16(2945.5), unconst_f16(11743.3)), vec4h(unconst_f16(1256.0), unconst_f16(2257.9), unconst_f16(15183.0), unconst_f16(1240.8)), unconst_f16(10464.2)))[3]); |
| var vf54: u32 = arrayLength(&buffer43); |
| vp10 = mat4x3h(f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10]), f16(buffer43[unconst_i32(-203)][10])); |
| vp10 = mat4x3h(vec3h(unpack4x8snorm(unconst_u32(326)).aar), vec3h(unpack4x8snorm(unconst_u32(326)).yxy), vec3h(unpack4x8snorm(unconst_u32(326)).aar), vec3h(unpack4x8snorm(unconst_u32(326)).zxz)); |
| switch vec4i(step(vec4h(unconst_f16(419.9), unconst_f16(23063.8), unconst_f16(2669.9), unconst_f16(7006.2)), vec4h(unconst_f16(-2566.8), unconst_f16(43420.6), unconst_f16(4848.2), unconst_f16(16676.4))))[1] { |
| default { |
| vp8 = VertexOutput3(vec4u(bitcast<u32>((*&buffer43)[unconst_u32(154)][10])), bitcast<vec2h>((*&buffer43)[unconst_u32(154)][10]), vec4f(bitcast<f32>((*&buffer43)[unconst_u32(154)][10]))); |
| vp10 = mat4x3h(f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10]), f16((*&buffer43)[arrayLength(&(*&buffer43))][10])); |
| _ = buffer43; |
| } |
| } |
| for (var it3=bitcast<u32>(determinant(mat2x2f(unconst_f32(0.00743), unconst_f32(0.09783), unconst_f32(0.1182), unconst_f32(0.1661)))); it3<u32(dot(vec2i(unconst_i32(103), unconst_i32(131)), vec2i(unconst_i32(-7), unconst_i32(133)))); it3++) { |
| vp9[unconst_u32(273)] = FragmentOutput1(vec4i(vp8.f6), vp8.f6, pack4x8unorm(vp8.f6)); |
| discard; |
| { |
| out = vec4f(vp9[0].f0); |
| break; |
| } |
| out *= vec4f(bitcast<f32>((*&buffer43)[arrayLength(&(*&buffer43)) - 1][10])); |
| _ = buffer43; |
| } |
| { |
| vp8.f5 = bitcast<vec2h>((*&buffer43)[arrayLength(&(*&buffer43))][10]); |
| let ptr35: ptr<storage, array<i32, 11>, read> = &buffer43[unconst_i32(-56)]; |
| while bool(buffer43[arrayLength(&buffer43)][10]) { |
| let vf55: u32 = (unconst_u32(214) >> unconst_u32(27)); |
| return out; |
| } |
| out += vec4f(bitcast<f32>(buffer43[bitcast<u32>(vp8.f5)][10])); |
| _ = buffer43; |
| } |
| let vf56: vec2h = ceil(vec2h(unconst_f16(2471.9), unconst_f16(31164.7))); |
| loop { |
| vp8.f6 *= vec4f(bitcast<f32>((*&buffer43)[unconst_u32(69)][10])); |
| break; |
| _ = buffer43; |
| } |
| vf54 >>= pack4x8snorm(vp9[unconst_u32(247)].f1); |
| switch vp9[unconst_u32(186)].f0[3] { |
| default { |
| let ptr36: ptr<private, vec4f> = &vp9[0].f1; |
| var vf57: vec2f = degrees(vec2f(unconst_f32(0.00747), unconst_f32(-0.6569))); |
| vf57 -= vec2f(vp8.f5); |
| out *= vec4f(f32(buffer43[unconst_u32(314)][10])); |
| return out; |
| _ = buffer43; |
| } |
| } |
| return out; |
| _ = buffer43; |
| }`, |
| }); |
| let buffer44 = device0.createBuffer({ |
| size: 20498, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup31, [2816]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 1292, new Int16Array(5613), 1050, 288); |
| } catch {} |
| document.body.append(img0); |
| let buffer45 = device0.createBuffer({size: 1459, usage: GPUBufferUsage.COPY_DST}); |
| let texture102 = device0.createTexture({ |
| size: [1, 196, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture103 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder83 = commandEncoder75.beginComputePass({}); |
| let sampler54 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'greater-equal', |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup16, [0]); |
| } catch {} |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup24, new Uint32Array(37), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder37.end(); |
| } catch {} |
| try { |
| computePassEncoder80.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2800 */ |
| offset: 2800, |
| bytesPerRow: 17920, |
| buffer: buffer23, |
| }, { |
| texture: texture75, |
| mipLevel: 2, |
| origin: {x: 0, y: 26, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let textureView83 = texture102.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let computePassEncoder84 = commandEncoder80.beginComputePass(); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16sint'], |
| depthStencilFormat: 'stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let sampler55 = device0.createSampler({addressModeV: 'clamp-to-edge', lodMaxClamp: 87.76}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup21, new Uint32Array(1510), 652, 1); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline14 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| multisample: {count: 4, mask: 0xa321720}, |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| stencilFront: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'increment-wrap'}, |
| stencilBack: {compare: 'never', failOp: 'keep', depthFailOp: 'zero', passOp: 'increment-wrap'}, |
| stencilReadMask: 8921187, |
| stencilWriteMask: 1325500624, |
| depthBiasSlopeScale: -78.7629908253929, |
| }, |
| vertex: {module: shaderModule3, buffers: []}, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw'}, |
| }); |
| let textureView84 = texture23.createView({ |
| dimension: 'cube-array', |
| format: 'rg16float', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| let texture104 = device0.createTexture({ |
| size: {width: 1, height: 136, depthOrArrayLayers: 20}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder85 = commandEncoder50.beginComputePass({}); |
| try { |
| computePassEncoder69.setBindGroup(1, bindGroup38, [256]); |
| } catch {} |
| try { |
| computePassEncoder74.setBindGroup(0, bindGroup14, new Uint32Array(1159), 204, 1); |
| } catch {} |
| try { |
| computePassEncoder75.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer7, 'uint32', 464, 338); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(99).fill(107), /* required buffer size: 99 */ |
| {offset: 99, bytesPerRow: 531}, {width: 126, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| document.body.prepend(img0); |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| let textureView85 = texture15.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder86 = commandEncoder66.beginComputePass(); |
| let renderBundle8 = renderBundleEncoder8.finish({}); |
| try { |
| device0.queue.writeBuffer(buffer13, 272, new BigUint64Array(3923), 5, 84); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer3, offset: 0, size: 2276}}], |
| }); |
| let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]}); |
| let commandEncoder84 = device0.createCommandEncoder({label: '\u89d0\uc7fc\udf26\u{1fa2a}\u0737\u5960\udfe8'}); |
| let texture105 = device0.createTexture({ |
| size: [839, 1, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler56 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 91.88, |
| maxAnisotropy: 6, |
| }); |
| let recycledExplicitBindGroupLayout8 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let computePassEncoder87 = commandEncoder82.beginComputePass({}); |
| try { |
| computePassEncoder77.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder85.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 704 */ |
| offset: 704, |
| buffer: buffer14, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let commandBuffer8 = commandEncoder73.finish({}); |
| let textureView86 = texture57.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder62.setBindGroup(0, bindGroup27, [0]); |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder81.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4840 */ |
| offset: 4840, |
| buffer: buffer38, |
| }, { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 209, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let textureView87 = texture3.createView({aspect: 'all', baseArrayLayer: 8, arrayLayerCount: 2}); |
| try { |
| computePassEncoder85.setBindGroup(2, bindGroup24, new Uint32Array(508), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder69.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 2176, new BigUint64Array(7631), 1587, 12); |
| } catch {} |
| let textureView88 = texture97.createView({dimension: '2d-array', aspect: 'stencil-only'}); |
| let computePassEncoder88 = commandEncoder86.beginComputePass({}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup17, []); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [{binding: 174, resource: {buffer: buffer15, offset: 2048, size: 1236}}], |
| }); |
| let computePassEncoder89 = commandEncoder59.beginComputePass({}); |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline6); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let computePassEncoder90 = commandEncoder8.beginComputePass({}); |
| try { |
| device0.queue.writeBuffer(buffer42, 11640, new BigUint64Array(5010), 186, 40); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| let imageData7 = new ImageData(16, 208); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [{binding: 174, resource: {buffer: buffer40, offset: 512, size: 792}}], |
| }); |
| try { |
| computePassEncoder82.setBindGroup(0, bindGroup27, new Uint32Array(2726), 285, 1); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 1260, new Float32Array(2702), 414, 108); |
| } catch {} |
| let buffer46 = device0.createBuffer({size: 6240, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let texture106 = device0.createTexture({size: [419, 1, 1], format: 'stencil8', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder91 = commandEncoder72.beginComputePass({}); |
| let sampler57 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.27, |
| maxAnisotropy: 5, |
| }); |
| try { |
| commandEncoder87.copyBufferToTexture({ |
| /* bytesInLastRow: 146 widthInBlocks: 73 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1818 */ |
| offset: 1818, |
| buffer: buffer41, |
| }, { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 903, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 73, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'jedecP22Phosphors', transfer: 'pq'} }); |
| let buffer47 = device0.createBuffer({ |
| size: 13872, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let querySet9 = device0.createQuerySet({type: 'occlusion', count: 13}); |
| let texture107 = device0.createTexture({ |
| size: {width: 1, height: 273, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView89 = texture15.createView({mipLevelCount: 1}); |
| let computePassEncoder92 = commandEncoder36.beginComputePass({}); |
| try { |
| computePassEncoder87.setBindGroup(0, bindGroup27, [768]); |
| } catch {} |
| try { |
| computePassEncoder90.setBindGroup(3, bindGroup29, new Uint32Array(3273), 772, 1); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder78.copyTextureToBuffer({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 452 */ |
| offset: 452, |
| buffer: buffer8, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder88 = device0.createCommandEncoder(); |
| let commandBuffer9 = commandEncoder84.finish(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroupsIndirect(buffer22, 236); }; |
| } catch {} |
| try { |
| computePassEncoder92.setPipeline(pipeline12); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 2, |
| origin: {x: 0, y: 90, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(964).fill(251), /* required buffer size: 964 */ |
| {offset: 964}, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let buffer48 = device0.createBuffer({size: 24534, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let textureView90 = texture98.createView({ |
| dimension: 'cube-array', |
| format: 'rg16uint', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 4, |
| arrayLayerCount: 6, |
| }); |
| let texture108 = device0.createTexture({ |
| size: {width: 1, height: 273, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler58 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 86.94}); |
| try { |
| computePassEncoder49.setBindGroup(2, bindGroup28, [11264]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer14, 1_496); }; |
| } catch {} |
| try { |
| computePassEncoder84.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer45, 44, new DataView(new ArrayBuffer(1190)), 121, 196); |
| } catch {} |
| let textureView91 = texture105.createView({aspect: 'all'}); |
| let computePassEncoder93 = commandEncoder83.beginComputePass({}); |
| try { |
| computePassEncoder86.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| commandEncoder78.resolveQuerySet(querySet4, 37, 89, buffer39, 0); |
| } catch {} |
| document.body.prepend(img0); |
| let imageData8 = new ImageData(16, 84); |
| let bindGroup42 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer42, offset: 1280}}], |
| }); |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| let textureView92 = texture73.createView({}); |
| let texture109 = device0.createTexture({ |
| size: {width: 4, height: 1575, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer14, 1_536); }; |
| } catch {} |
| try { |
| computePassEncoder88.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder78.resolveQuerySet(querySet2, 3, 45, buffer42, 1280); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup19, [256]); |
| } catch {} |
| try { |
| computePassEncoder90.setPipeline(pipeline8); |
| } catch {} |
| document.body.prepend(img0); |
| let textureView93 = texture61.createView({}); |
| let imageBitmap1 = await createImageBitmap(imageData8); |
| let bindGroup43 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 59, resource: textureView20}]}); |
| let sampler59 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 98.80}); |
| try { |
| computePassEncoder89.setPipeline(pipeline8); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [{binding: 174, resource: {buffer: buffer28, offset: 4608, size: 2120}}], |
| }); |
| let buffer49 = device0.createBuffer({ |
| size: 8272, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture110 = device0.createTexture({size: [1, 273, 1], format: 'r16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| computePassEncoder91.setPipeline(pipeline6); |
| } catch {} |
| let buffer50 = device0.createBuffer({size: 13845, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let computePassEncoder94 = commandEncoder81.beginComputePass({}); |
| try { |
| computePassEncoder77.setBindGroup(0, bindGroup21, [0]); |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder87.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 0, y: 7, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 20, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| struct S3 { |
| @location(10) f0: i32, |
| } |
| |
| var<workgroup> vw10: bool; |
| |
| var<workgroup> vw9: array<atomic<i32>, 28>; |
| |
| override override11: i32 = 354; |
| |
| struct S2 { |
| @location(1) @interpolate(linear, either) f0: f32, |
| } |
| |
| override override9: i32; |
| |
| var<workgroup> vw8: S2; |
| |
| struct T0 { |
| @size(76) f0: array<u32>, |
| } |
| |
| struct S1 { |
| @location(6) @interpolate(flat, either) f0: vec2f, |
| @location(14) @interpolate(flat, first) f1: vec2h, |
| } |
| |
| override override8: f32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw11: FragmentOutput2; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct FragmentOutput2 { |
| @location(0) @interpolate(flat, center) f0: vec2f, |
| @location(3) f1: vec2i, |
| } |
| |
| struct T1 { |
| @size(44) f0: array<u32>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw12: VertexOutput5; |
| |
| struct VertexOutput5 { |
| @invariant @builtin(position) f8: vec4f, |
| } |
| |
| @group(0) @binding(174) var<storage, read> buffer51: array<S3, 11>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @id(5332) override override7 = 0.06215; |
| |
| var<workgroup> vw13: atomic<u32>; |
| |
| @id(19533) override override6 = -0.1803; |
| |
| var<private> vp11 = modf(f32(0.4078)); |
| |
| @id(12974) override override10 = true; |
| |
| /* used global variables: buffer51 */ |
| @vertex |
| fn vertex5(@location(7) a0: u32, @location(12) a1: vec2h, a2: S1, a3: S2, @location(2) a4: vec2f, @location(4) a5: i32, @location(11) a6: vec4h, a7: S3, @location(15) a8: u32, @location(9) @interpolate(flat) a9: vec4u, @location(3) @interpolate(perspective) a10: vec2f, @location(13) @interpolate(flat, first) a11: f16, @location(8) @interpolate(flat) a12: f32) -> VertexOutput5 { |
| var out: VertexOutput5; |
| out.f8 = vec4f(a3.f0); |
| out.f8 += vec4f(f32(buffer51[bitcast<vec2u>(a10)[1]].f0)); |
| vp11 = modf(bitcast<f32>((*&buffer51)[bitcast<u32>(unpack2x16float(unconst_u32(227)).g)].f0)); |
| out.f8 -= vec4f(a3.f0); |
| var vf58: vec2f = a4; |
| for (var it4=bitcast<u32>(normalize(vec2h(unconst_f16(8412.4), unconst_f16(19342.3)))); it4<bitcast<u32>(buffer51[unconst_u32(236)].f0); it4++) { |
| let vf59: bool = (i32(a6.b) >= unconst_i32(117)); |
| } |
| var vf60: vec4u = a9; |
| var vf61: f32 = override7; |
| vp11.fract -= tan(vec2f(unconst_f32(0.01108), unconst_f32(0.1584)))[1]; |
| vf60 = vec4u(bitcast<u32>(a7.f0)); |
| vf61 = f32(a2.f1[unconst_u32(15)]); |
| vf58 -= vec2f(bitcast<f32>(vf60[unconst_u32(9)])); |
| var vf62: u32 = a8; |
| out.f8 -= vec4f(f32((*&buffer51)[unconst_u32(278)].f0)); |
| var vf63: vec2h = pow(vec2h(unconst_f16(4570.5), unconst_f16(3165.1)), vec2h(unconst_f16(-8914.6), unconst_f16(4325.8))); |
| return out; |
| _ = override7; |
| _ = buffer51; |
| } |
| |
| /* used global variables: buffer51 */ |
| @fragment |
| fn fragment4() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| out.f1 ^= vec2i(i32(inverseSqrt(sin(vec3h(unconst_f16(8683.8), unconst_f16(1729.8), unconst_f16(13272.7)))[0]))); |
| var vf64: vec4i = unpack4xI8(unconst_u32(46)); |
| let ptr37: ptr<storage, S3, read> = &buffer51[unconst_u32(388)]; |
| var vf65: f32 = override8; |
| var vf66: vec3f = atanh(vec3f(unconst_f32(-0.07615), unconst_f32(0.1456), unconst_f32(0.1021))); |
| let ptr38: ptr<storage, S3, read> = &(*&buffer51)[unconst_u32(8)]; |
| var vf67: mat3x4f = (mat3x4f() - mat3x4f(vec4f(unpack4xI8(bitcast<u32>((*ptr37).f0))), vec4f(unpack4xI8(bitcast<u32>((*ptr37).f0))), vec4f(unpack4xI8(bitcast<u32>((*ptr37).f0))))); |
| vf66 = vec3f(f32(buffer51[unconst_u32(36)].f0)); |
| return out; |
| _ = override8; |
| _ = buffer51; |
| } |
| |
| /* used global variables: buffer51 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute4(@builtin(num_workgroups) a0: vec3u) { |
| var vf68: u32 = extractBits(unconst_u32(162), unconst_u32(42), u32(cos(vec3f(unconst_f32(0.1209), unconst_f32(0.1330), unconst_f32(0.04080)))[1])); |
| switch atomicLoad(&(*&vw9)[27]) { |
| default { |
| while bool(insertBits(vec2i(unconst_i32(101), unconst_i32(502)), vec2i(unconst_i32(474), unconst_i32(60)), atomicLoad(&(*&vw13)), unconst_u32(66)).r) { |
| vw12.f8 = vw12.f8; |
| let ptr39: ptr<workgroup, vec2i> = &(*&vw11).f1; |
| let vf69: u32 = atomicExchange(&(*&vw13), unconst_u32(464)); |
| let ptr40: ptr<workgroup, vec2f> = &vw11.f0; |
| let vf70: vec3<bool> = (vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)) != vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true))); |
| } |
| let ptr41: ptr<workgroup, FragmentOutput2> = &vw11; |
| vw11 = FragmentOutput2(bitcast<vec2f>(firstTrailingBit(vec3i(unconst_i32(196), unconst_i32(224), unconst_i32(-268))).rg), firstTrailingBit(vec3i(unconst_i32(196), unconst_i32(224), unconst_i32(-268))).xz); |
| vw8.f0 *= f32(smoothstep(unconst_f16(34193.3), unconst_f16(7747.7), unconst_f16(13163.6))); |
| vw11.f1 += vec2i(i32(override7)); |
| let vf71: mat3x2f = (mat3x2f(unconst_f32(0.3833), unconst_f32(0.2176), unconst_f32(0.07781), unconst_f32(0.00883), unconst_f32(0.1272), unconst_f32(0.05348)) * mat3x3f(unconst_f32(0.02804), unconst_f32(0.01872), unconst_f32(0.1030), unconst_f32(0.1285), unconst_f32(0.2216), unconst_f32(0.01547), unconst_f32(0.00068), unconst_f32(0.3099), unconst_f32(0.1784))); |
| let ptr42: ptr<workgroup, FragmentOutput2> = &vw11; |
| break; |
| _ = override7; |
| } |
| } |
| { |
| let ptr43: ptr<workgroup, vec2f> = &vw11.f0; |
| let ptr44: ptr<workgroup, array<atomic<i32>, 28>> = &vw9; |
| let vf72: f32 = vw11.f0[unconst_u32(89)]; |
| var vf73: vec2h = mix(vec2h(unconst_f16(13350.3), unconst_f16(9770.1)), bitcast<vec2h>(pack2x16float(vec2f(unconst_f32(0.1782), unconst_f32(0.7445)))), vec2h(unconst_f16(17743.2), unconst_f16(10591.8))); |
| } |
| vw12 = VertexOutput5(vec4f(f32(buffer51[unconst_u32(322)].f0))); |
| var vf74: vec3h = refract(vec3h(unconst_f16(23040.3), unconst_f16(-2468.1), unconst_f16(11893.2)), vec3h(unconst_f16(760.8), unconst_f16(4659.0), unconst_f16(-3503.5)), unconst_f16(57.04)); |
| let ptr45: ptr<storage, S3, read> = &buffer51[10]; |
| let vf75: mat3x2h = transpose(mat2x3h()); |
| let ptr46: ptr<workgroup, bool> = &(*&vw10); |
| let ptr47: ptr<workgroup, bool> = &(*ptr46); |
| let ptr48: ptr<storage, S3, read> = &(*ptr45); |
| atomicAdd(&vw13, unconst_u32(643)); |
| var vf76: f32 = override6; |
| while bool((*&vw11).f0.x) { |
| atomicStore(&vw9[unconst_u32(370)], i32(atomicLoad(&vw13))); |
| } |
| let ptr49: ptr<workgroup, vec4f> = &vw12.f8; |
| _ = override6; |
| _ = override7; |
| _ = buffer51; |
| }`, |
| }); |
| let commandEncoder91 = device0.createCommandEncoder({label: '\u0918\ud0e8\u0613\u{1fe28}\u{1f77b}\u{1fc15}\ufbe4\u046f\u2b86'}); |
| try { |
| computePassEncoder93.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder78.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1756 */ |
| offset: 1756, |
| buffer: buffer4, |
| }, { |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 80, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 1292}); |
| let texture111 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup25, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| commandEncoder78.copyTextureToTexture({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 212, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout9 = pipeline11.getBindGroupLayout(0); |
| let bindGroup45 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer42, offset: 512}}], |
| }); |
| let computePassEncoder95 = commandEncoder76.beginComputePass(); |
| try { |
| commandEncoder90.copyTextureToBuffer({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 540 widthInBlocks: 135 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2628 */ |
| offset: 2628, |
| bytesPerRow: 54016, |
| buffer: buffer44, |
| }, {width: 135, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder88.clearBuffer(buffer16, 392, 128); |
| } catch {} |
| let bindGroup46 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer28, offset: 1024, size: 5784}}, |
| {binding: 70, resource: {buffer: buffer47, offset: 256}}, |
| ], |
| }); |
| let buffer52 = device0.createBuffer({ |
| size: 3080, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture112 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder96 = commandEncoder87.beginComputePass({}); |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder85.copyBufferToBuffer(buffer49, 556, buffer9, 6444, 2296); |
| } catch {} |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4200 */ |
| offset: 4200, |
| bytesPerRow: 41728, |
| buffer: buffer44, |
| }, { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 0, y: 84, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 99, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder90.clearBuffer(buffer9, 1244, 4532); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 85} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 25, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 0, y: 99, z: 28}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer53 = device0.createBuffer({size: 16626, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let querySet11 = device0.createQuerySet({type: 'occlusion', count: 987}); |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 64 */ |
| offset: 64, |
| bytesPerRow: 26624, |
| buffer: buffer29, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 0, y: 15, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder67.insertDebugMarker('\u{1fc0b}'); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt709', transfer: 'hlg'} }); |
| let bindGroup47 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [{binding: 174, resource: {buffer: buffer35, offset: 2048, size: 4128}}], |
| }); |
| let buffer54 = device0.createBuffer({size: 19431, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| try { |
| commandEncoder90.copyBufferToBuffer(buffer41, 572, buffer45, 152, 4); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3952 */ |
| offset: 3952, |
| bytesPerRow: 19456, |
| buffer: buffer38, |
| }, { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 0, y: 378, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 641, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder88.clearBuffer(buffer19, 624, 384); |
| } catch {} |
| try { |
| commandEncoder85.resolveQuerySet(querySet6, 4, 3, buffer16, 256); |
| } catch {} |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: { |
| fullRange: true, |
| matrix: 'unspecified', |
| primaries: 'jedecP22Phosphors', |
| transfer: 'bt1361ExtendedColourGamut', |
| } }); |
| let bindGroup48 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer52, offset: 0, size: 400}}], |
| }); |
| let texture113 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 28}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView94 = texture31.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder97 = commandEncoder90.beginComputePass({}); |
| try { |
| commandEncoder85.copyTextureToTexture({ |
| texture: texture17, |
| mipLevel: 1, |
| origin: {x: 0, y: 341, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture62, |
| mipLevel: 3, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let textureView95 = texture5.createView({ |
| dimension: '2d', |
| aspect: 'stencil-only', |
| baseMipLevel: 2, |
| mipLevelCount: 1, |
| baseArrayLayer: 1, |
| arrayLayerCount: 1, |
| }); |
| let computePassEncoder98 = commandEncoder78.beginComputePass({}); |
| let sampler60 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', compare: 'greater-equal'}); |
| try { |
| computePassEncoder97.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer52.unmap(); |
| } catch {} |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 210 widthInBlocks: 105 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1012 */ |
| offset: 1012, |
| bytesPerRow: 80128, |
| rowsPerImage: 249, |
| buffer: buffer47, |
| }, { |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 105, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let querySet12 = device0.createQuerySet({type: 'occlusion', count: 565}); |
| let textureView96 = texture35.createView({dimension: '2d-array'}); |
| let computePassEncoder99 = commandEncoder88.beginComputePass(); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup3, new Uint32Array(4416), 1_900, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer26, 1_868); }; |
| } catch {} |
| let arrayBuffer6 = buffer1.getMappedRange(0, 40); |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 79, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 209, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder98.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup28, new Uint32Array(443), 7, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer31, 'uint32', 200, 176); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| commandEncoder92.copyTextureToTexture({ |
| texture: texture47, |
| mipLevel: 2, |
| origin: {x: 207, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let querySet13 = device0.createQuerySet({type: 'occlusion', count: 3}); |
| let computePassEncoder100 = commandEncoder91.beginComputePass(); |
| let renderBundle9 = renderBundleEncoder9.finish({}); |
| let sampler61 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 57.80, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder99.setPipeline(pipeline12); |
| } catch {} |
| try { |
| commandEncoder89.copyTextureToTexture({ |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 1667, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture75, |
| mipLevel: 1, |
| origin: {x: 0, y: 31, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 77, resource: textureView30}, {binding: 432, resource: textureView42}], |
| }); |
| let buffer55 = device0.createBuffer({size: 9645, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let computePassEncoder101 = commandEncoder92.beginComputePass({}); |
| let sampler62 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 95.46, |
| }); |
| try { |
| computePassEncoder100.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder89.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 2, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 126 widthInBlocks: 63 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1238 */ |
| offset: 1238, |
| rowsPerImage: 281, |
| buffer: buffer33, |
| }, {width: 63, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 180, new Int16Array(7174), 1233, 128); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture63, |
| mipLevel: 2, |
| origin: {x: 0, y: 28, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(516).fill(106), /* required buffer size: 516 */ |
| {offset: 516, bytesPerRow: 24}, {width: 0, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| label: '\u6811\u{1f981}\udd1a\ud720\u047d\u0933\uadc8', |
| entries: [ |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 202, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture114 = device0.createTexture({ |
| size: [1, 196, 997], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView97 = texture5.createView({aspect: 'stencil-only', format: 'stencil8', mipLevelCount: 2, arrayLayerCount: 5}); |
| let sampler63 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat', lodMinClamp: 68.36, lodMaxClamp: 68.69}); |
| try { |
| computePassEncoder38.setBindGroup(3, bindGroup13, new Uint32Array(7044), 279, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder72); computePassEncoder72.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| commandEncoder85.copyBufferToTexture({ |
| /* bytesInLastRow: 372 widthInBlocks: 186 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1594 */ |
| offset: 1594, |
| bytesPerRow: 15104, |
| rowsPerImage: 712, |
| buffer: buffer29, |
| }, { |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 56, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 186, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let texture115 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView98 = texture21.createView({dimension: '2d-array', format: 'stencil8', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder92.setBindGroup(1, bindGroup32, new Uint32Array(1057), 105, 1); |
| } catch {} |
| try { |
| computePassEncoder101.setPipeline(pipeline12); |
| } catch {} |
| let arrayBuffer7 = buffer1.getMappedRange(40, 48); |
| try { |
| commandEncoder93.copyBufferToTexture({ |
| /* bytesInLastRow: 419 widthInBlocks: 419 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2152 */ |
| offset: 2152, |
| bytesPerRow: 21504, |
| buffer: buffer35, |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 419, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 11720, new BigUint64Array(25474), 422, 216); |
| } catch {} |
| let texture116 = device0.createTexture({ |
| size: [1, 547, 1], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView99 = texture93.createView({baseMipLevel: 0}); |
| let computePassEncoder102 = commandEncoder93.beginComputePass({}); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| computePassEncoder85.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder96.setPipeline(pipeline12); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(69, 46); |
| let bindGroup50 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout9, |
| entries: [{binding: 174, resource: {buffer: buffer25, offset: 1536, size: 92}}], |
| }); |
| let textureView100 = texture106.createView({dimension: '2d'}); |
| let computePassEncoder103 = commandEncoder85.beginComputePass(); |
| try { |
| commandEncoder89.copyTextureToBuffer({ |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 0, y: 247, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 860 */ |
| offset: 860, |
| bytesPerRow: 27136, |
| buffer: buffer21, |
| }, {width: 0, height: 148, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder89.clearBuffer(buffer9, 28572, 924); |
| } catch {} |
| document.body.append(img0); |
| let texture117 = device0.createTexture({ |
| size: [4, 1575, 1], |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder96.setBindGroup(1, bindGroup8, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer4, 6_820); }; |
| } catch {} |
| let texture118 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 1}, |
| mipLevelCount: 11, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder104 = commandEncoder89.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer35, 4_756); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer33, 2676, new Int16Array(95), 18, 52); |
| } catch {} |
| let imageData9 = new ImageData(16, 32); |
| let commandEncoder95 = device0.createCommandEncoder({label: '\uf6e4\u2da0\u06ed\ufc9b\u6762\ub276\u4c14\u0740'}); |
| let sampler64 = device0.createSampler({ |
| label: '\u0424\u3fb6\uac0d\u{1f7c2}\u{1fc95}\u028e\u{1fc01}\u{1fdc3}\u0ddc\u01cc', |
| addressModeU: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 98.44, |
| }); |
| try { |
| computePassEncoder82.setBindGroup(1, bindGroup24); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer18, 972, new Float32Array(5299), 206, 1108); |
| } catch {} |
| let recycledExplicitBindGroupLayout10 = pipeline6.getBindGroupLayout(0); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let textureView101 = texture34.createView({dimension: '2d', aspect: 'stencil-only'}); |
| try { |
| computePassEncoder95.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 393, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture96, |
| mipLevel: 2, |
| origin: {x: 0, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline15 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule1, constants: {}}}); |
| let bindGroup51 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer35, offset: 14592, size: 6008}}, |
| {binding: 70, resource: {buffer: buffer52, offset: 0, size: 1172}}, |
| ], |
| }); |
| let buffer56 = device0.createBuffer({ |
| size: 20612, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture119 = device0.createTexture({ |
| size: [4, 1575, 1], |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder105 = commandEncoder96.beginComputePass({}); |
| let sampler65 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 82.47, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder104.setPipeline(pipeline2); |
| } catch {} |
| let arrayBuffer8 = buffer1.getMappedRange(552, 0); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 1175, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(389).fill(141), /* required buffer size: 389 */ |
| {offset: 389}, {width: 913, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 393, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 6, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture96, |
| mipLevel: 2, |
| origin: {x: 0, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer57 = device0.createBuffer({ |
| size: 52304, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let querySet14 = device0.createQuerySet({type: 'occlusion', count: 1185}); |
| let commandEncoder98 = device0.createCommandEncoder(); |
| let textureView102 = texture81.createView({}); |
| let sampler66 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 55.06}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroupsIndirect(buffer25, 92); }; |
| } catch {} |
| try { |
| computePassEncoder103.setPipeline(pipeline15); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt709', transfer: 'smpte240m'} }); |
| let buffer58 = device0.createBuffer({size: 15566, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let texture120 = device0.createTexture({ |
| size: [419, 1, 2048], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView103 = texture71.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder106 = commandEncoder97.beginComputePass({}); |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup33, [512]); |
| } catch {} |
| try { |
| computePassEncoder72.end(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer54, 304, new Float32Array(206), 49, 48); |
| } catch {} |
| let commandBuffer10 = commandEncoder56.finish(); |
| let texture121 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 48}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder107 = commandEncoder94.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder106.setPipeline(pipeline6); |
| } catch {} |
| try { |
| computePassEncoder2.pushDebugGroup('\u9904'); |
| } catch {} |
| document.body.prepend(img0); |
| let recycledExplicitBindGroupLayout11 = pipeline5.getBindGroupLayout(0); |
| let bindGroup52 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [{binding: 174, resource: {buffer: buffer3, offset: 0, size: 544}}], |
| }); |
| let computePassEncoder108 = commandEncoder98.beginComputePass(); |
| let sampler67 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'clamp-to-edge', minFilter: 'nearest'}); |
| try { |
| computePassEncoder38.setPipeline(pipeline15); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| let texture122 = device0.createTexture({ |
| size: [3357, 1, 1], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder109 = commandEncoder100.beginComputePass({}); |
| try { |
| computePassEncoder108.setPipeline(pipeline6); |
| } catch {} |
| await gc(); |
| let imageBitmap2 = await createImageBitmap(videoFrame3); |
| let bindGroup53 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer25, offset: 1536, size: 532}}], |
| }); |
| let buffer59 = device0.createBuffer({size: 44896, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let texture123 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 371}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView104 = texture109.createView({}); |
| try { |
| computePassEncoder71.setBindGroup(0, bindGroup16, new Uint32Array(1236), 120, 1); |
| } catch {} |
| try { |
| computePassEncoder107.setPipeline(pipeline3); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'jedecP22Phosphors', transfer: 'pq'} }); |
| let buffer60 = device0.createBuffer({ |
| size: 22733, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView105 = texture88.createView({dimension: '2d-array', format: 'rg16uint', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 1}); |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentOutput3 { |
| @location(1) @interpolate(flat) f0: vec4u, |
| @location(0) f1: vec2i, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @id(35410) override override12: i32; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| @size(44) f0: array<atomic<u32>, 1>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput6 { |
| @builtin(position) f9: vec4f, |
| @location(12) f10: vec2h, |
| @location(13) @interpolate(linear, first) f11: vec2h, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex6() -> VertexOutput6 { |
| var out: VertexOutput6; |
| while bool(max(vec2i(unconst_i32(318), unconst_i32(-88)), vec2i(unconst_i32(313), unconst_i32(171))).y) { |
| var vf77: vec4h = sinh(vec4h(unconst_f16(43246.7), unconst_f16(18020.5), unconst_f16(3079.7), unconst_f16(-1784.9))); |
| var vf78: vec4i = (vec4i(i32(all(unconst_bool(true)))) ^ vec4i(unconst_i32(149), unconst_i32(390), unconst_i32(-27), unconst_i32(337))); |
| loop { |
| while bool(pack4x8unorm(vec4f(unconst_f32(0.1790), unconst_f32(0.5858), unconst_f32(0.1902), unconst_f32(0.08638)))) { |
| let vf79: u32 = countTrailingZeros(unconst_u32(210)); |
| out.f9 = unpack4x8snorm(pack4xI8Clamp(vec4i(unconst_i32(184), unconst_i32(-59), unconst_i32(454), unconst_i32(49)))); |
| let vf80: vec4f = smoothstep(vec4f(unconst_f32(0.4528), unconst_f32(0.3306), unconst_f32(-0.01555), unconst_f32(0.06310)), vec4f(unconst_f32(0.05649), unconst_f32(0.1847), unconst_f32(0.2116), unconst_f32(0.04102)), vec4f(unconst_f32(0.06518), unconst_f32(0.2630), unconst_f32(0.00002), unconst_f32(-0.00680))); |
| return out; |
| } |
| break; |
| } |
| var vf81: vec4f = atan(unpack4x8snorm(unconst_u32(125))); |
| loop { |
| var vf82: vec3i = sign(vec3i(unconst_i32(-10), unconst_i32(187), unconst_i32(218))); |
| out.f9 = vec4f(transpose(mat2x3h(unconst_f16(18314.3), unconst_f16(698.4), unconst_f16(2185.4), unconst_f16(14003.5), unconst_f16(15466.1), unconst_f16(16925.3)))[unconst_i32(2)].yxyy); |
| let vf83: f16 = inverseSqrt(unconst_f16(-3107.7)); |
| var vf84: vec3i = sign(vec3i(unconst_i32(24), unconst_i32(162), unconst_i32(18))); |
| break; |
| } |
| let vf85: vec4u = (vec4u(unconst_u32(128), unconst_u32(255), unconst_u32(324), unconst_u32(121)) >> vec4u(unconst_u32(236), unconst_u32(160), unconst_u32(185), unconst_u32(264))); |
| while bool(exp(vec2f(unconst_f32(0.3289), unconst_f32(0.1912))).y) { |
| var vf86: vec2h = (vec2h((vec4f(unconst_f32(0.4148), unconst_f32(0.03704), unconst_f32(0.03616), unconst_f32(0.1497)) == vec4f(unconst_f32(0.05229), unconst_f32(0.2899), unconst_f32(-0.00409), unconst_f32(0.05226))).ag) / unconst_f16(4689.6)); |
| let vf87: u32 = countOneBits(unconst_u32(90)); |
| var vf88: vec3h = ceil(vec3h(vf86[unconst_u32(19)])); |
| return out; |
| } |
| break; |
| } |
| var vf89: vec4i = (vec4i(unconst_i32(3), unconst_i32(26), unconst_i32(148), unconst_i32(444)) & vec4i(i32((unconst_bool(true) && unconst_bool(true))))); |
| let ptr50: ptr<function, vec4i> = &vf89; |
| var vf90: i32 = (*ptr50)[unconst_u32(208)]; |
| vf89 &= (vec4i(unconst_i32(-40), unconst_i32(161), unconst_i32(304), unconst_i32(197)) & vec4i(unconst_i32(220), unconst_i32(104), unconst_i32(213), unconst_i32(82))); |
| var vf91: vec2i = max(vec2i(unconst_i32(1), unconst_i32(-14)), vec2i(unconst_i32(2), unconst_i32(-168))); |
| let vf92: vec2h = reflect(vec2h(unconst_f16(40170.5), unconst_f16(7552.4)), vec2h(unconst_f16(5908.4), unconst_f16(3318.3))); |
| let vf93: f16 = determinant(mat3x3h(unconst_f16(1853.9), unconst_f16(4865.6), unconst_f16(2199.5), unconst_f16(4271.4), unconst_f16(-1142.2), unconst_f16(16570.0), unconst_f16(8944.1), unconst_f16(25580.9), unconst_f16(25095.7))); |
| var vf94: f16 = determinant(mat3x3h(unconst_f16(394.6), unconst_f16(6170.4), unconst_f16(2844.4), unconst_f16(13115.7), unconst_f16(5617.0), unconst_f16(10742.0), unconst_f16(10866.1), unconst_f16(23950.5), unconst_f16(3016.5))); |
| out.f11 = min(vec3h(unconst_f16(9176.3), unconst_f16(5341.1), unconst_f16(16215.1)), vec3h(unconst_f16(-14106.2), unconst_f16(2634.6), unconst_f16(1297.3))).rg; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment5() -> @location(200) vec4u { |
| var out: vec4u; |
| out = vec4u(bitcast<u32>(override12)); |
| out = vec4u((vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false)) & vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true))).ggbr); |
| out = unpack4xU8(bitcast<u32>(inverseSqrt(unconst_f32(0.1221)))); |
| out -= vec4u((vec3h(round(unconst_f16(1898.5))) < vec3h(unconst_f16(2826.5), unconst_f16(23283.0), unconst_f16(15188.4))).zyxz); |
| var vf95: f32 = trunc(unconst_f32(0.06536)); |
| let vf96: bool = (unconst_u32(172) < unconst_u32(92)); |
| out -= bitcast<vec4u>((vec2i(unconst_i32(227), unconst_i32(173)) << vec2u(unconst_u32(15), unconst_u32(61))).rrrg); |
| var vf97: f32 = (unconst_f32(0.2713) % unconst_f32(0.05609)); |
| let vf98: bool = all(vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false), unconst_bool(true))); |
| while bool(floor(unconst_f32(0.01390))) { |
| var vf99: vec3h = asinh(vec3h(unconst_f16(28944.2), unconst_f16(7321.0), unconst_f16(8553.3))); |
| let ptr51: ptr<function, vec3h> = &vf99; |
| let vf100: vec3h = asinh(vec3h(unconst_f16(2396.7), unconst_f16(23710.7), unconst_f16(13404.9))); |
| break; |
| } |
| vf97 = inverseSqrt(unconst_f32(0.3026)); |
| var vf101: vec2h = floor(min(vec2h(unconst_f16(15923.9), unconst_f16(15105.6)), vec2h(unconst_f16(19298.8), unconst_f16(7651.6)))); |
| vf97 = floor(unconst_f32(1.000)); |
| return out; |
| _ = override12; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment6(@location(8) a0: vec2h) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| var vf102: vec2i = reverseBits(vec2i(unconst_i32(-1), unconst_i32(272))); |
| out.f1 = vec2i(vf102[bitcast<vec2u>(asinh(vec2f(unconst_f32(0.5596), unconst_f32(-0.2441))))[0]]); |
| discard; |
| let vf103: bool = any(vec2<bool>(unconst_bool(true), unconst_bool(true))); |
| out.f1 = bitcast<vec2i>(unpack4xU8(unconst_u32(180)).yx); |
| while (unconst_f16(10442.2) < unconst_f16(944.8)) { |
| let vf104: u32 = pack4x8unorm(vec4f(unconst_f32(0.1996), unconst_f32(0.1796), unconst_f32(0.08893), unconst_f32(0.1801))); |
| for (var it5=bitcast<u32>(faceForward(vec2h(unconst_f16(8997.5), unconst_f16(8980.4)), vec2h(unconst_f16(25703.5), unconst_f16(16.23)), vec2h(unconst_f16(3892.1), unconst_f16(-15879.8)))); it5<bitcast<u32>(firstLeadingBit(vec4i(unconst_i32(-213), unconst_i32(423), unconst_i32(-52), unconst_i32(18))).y); it5++) { |
| out.f0 |= vec4u(mix(vec4h(unconst_f16(5124.6), unconst_f16(53102.2), unconst_f16(10054.8), unconst_f16(7827.8)), vec4h(unconst_f16(26320.3), unconst_f16(7030.3), unconst_f16(568.1), unconst_f16(1449.2)), unconst_f16(40031.3))); |
| let vf105: bool = (unconst_bool(true) | unconst_bool(false)); |
| var vf106: vec2f = degrees(vec2f(unconst_f32(0.3181), unconst_f32(0.01835))); |
| let vf107: vec4f = fma(vec4f(unconst_f32(0.2699), unconst_f32(0.03386), unconst_f32(0.1671), unconst_f32(0.02054)), vec4f(unconst_f32(0.00980), unconst_f32(0.09005), unconst_f32(0.1805), unconst_f32(0.1055)), vec4f(unconst_f32(0.02417), unconst_f32(0.1395), unconst_f32(0.2114), unconst_f32(0.08025))); |
| let vf108: vec4f = unpack4x8unorm(unconst_u32(430)); |
| } |
| out.f0 = vec4u(pack4xI8Clamp(vec4i(unconst_i32(130), unconst_i32(122), unconst_i32(31), unconst_i32(60)))); |
| var vf109: vec3h = min(vec3h(unconst_f16(8831.7), unconst_f16(2573.2), unconst_f16(11356.5)), vec3h(unconst_f16(31190.3), unconst_f16(2276.6), unconst_f16(12915.6))); |
| var vf110: vec3f = mix(vec3f(firstLeadingBit(vec4i(unconst_i32(159), unconst_i32(24), unconst_i32(-54), unconst_i32(178))).rga), vec3f(bitcast<f32>(dot4I8Packed(unconst_u32(24), unconst_u32(121)))), vec3f(unconst_f32(0.03999), unconst_f32(0.1194), unconst_f32(-0.2379))); |
| out.f1 &= vec2i(min(vec3h(unconst_f16(8529.3), unconst_f16(-3420.6), unconst_f16(25784.3)), vec3h(unconst_f16(2745.5), unconst_f16(8397.2), unconst_f16(917.8))).bg); |
| out.f1 *= vec2i(bitcast<i32>(vf110[unconst_u32(22)])); |
| break; |
| } |
| out.f1 += vec2i(i32(pack4x8unorm(vec4f(unconst_f32(0.01809), unconst_f32(0.07307), unconst_f32(0.1509), unconst_f32(0.5169))))); |
| let ptr52: ptr<function, vec2i> = &vf102; |
| let vf111: f16 = a0[unconst_u32(4)]; |
| vf102 += (*ptr52); |
| let vf112: vec4h = asinh(vec4h((unconst_f32(0.1204) - vec3f(unconst_f32(0.09700), unconst_f32(-0.03144), unconst_f32(0.06000))).gbbg)); |
| let vf113: vec4h = normalize(vec4h(unconst_f16(9627.4), unconst_f16(-19593.9), unconst_f16(49507.3), unconst_f16(3071.9))); |
| let ptr53: ptr<function, vec2i> = &vf102; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(2, 1, 2) |
| fn compute5(@builtin(global_invocation_id) a0: vec3u, @builtin(workgroup_id) a1: vec3u, @builtin(num_workgroups) a2: vec3u) { |
| var vf114: u32 = pack4xU8Clamp(vec4u(unconst_u32(55), unconst_u32(150), unconst_u32(367), unconst_u32(69))); |
| let vf115: vec3u = a2; |
| vf114 ^= u32((unconst_bool(false) && unconst_bool(true))); |
| vf114 += vf115.x; |
| }`, |
| }); |
| let commandBuffer11 = commandEncoder19.finish(); |
| let texture124 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder110 = commandEncoder101.beginComputePass(); |
| try { |
| computePassEncoder110.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder99.insertDebugMarker('\u0e27'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 209, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 47, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| textureView98.label = '\u9a1e\u7bb5\u0e7e\u0109\u0047\u9da6\u0c74\ud31d\uf35d'; |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| let textureView106 = texture114.createView({}); |
| let texture125 = device0.createTexture({ |
| size: [1678, 1, 58], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder111 = commandEncoder99.beginComputePass(); |
| try { |
| computePassEncoder93.setBindGroup(0, bindGroup4, new Uint32Array(1795), 598, 1); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 816, new DataView(new ArrayBuffer(27423)), 272, 4); |
| } catch {} |
| let buffer62 = device0.createBuffer({ |
| size: 5182, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView107 = texture77.createView({dimension: '2d-array'}); |
| let computePassEncoder112 = commandEncoder95.beginComputePass({}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], stencilReadOnly: true}); |
| let renderBundle10 = renderBundleEncoder10.finish({}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup10, [1280]); |
| } catch {} |
| try { |
| computePassEncoder103.insertDebugMarker('\ua320'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer11]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 787, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 3, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture119, |
| mipLevel: 1, |
| origin: {x: 0, y: 261, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView108 = texture117.createView({ |
| label: '\u1649\u{1fedb}\u65d5\uc5d8\u{1f983}\ue602\u{1fba5}\u0be0\udf5a\u0e57', |
| dimension: '2d-array', |
| }); |
| try { |
| computePassEncoder89.setBindGroup(0, bindGroup27, [0]); |
| } catch {} |
| try { |
| computePassEncoder105.setPipeline(pipeline12); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let textureView109 = texture9.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 5}); |
| let computePassEncoder113 = commandEncoder102.beginComputePass({}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroupsIndirect(buffer19, 1_840); }; |
| } catch {} |
| try { |
| computePassEncoder27.end(); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToBuffer(buffer35, 1464, buffer54, 3812, 1920); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 884 */ |
| offset: 884, |
| rowsPerImage: 1193, |
| buffer: buffer44, |
| }, { |
| texture: texture101, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder28.clearBuffer(buffer18, 600, 116); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer25, offset: 0, size: 1332}}], |
| }); |
| let textureView110 = texture76.createView({dimension: '2d-array', aspect: 'all'}); |
| let computePassEncoder114 = commandEncoder28.beginComputePass({}); |
| try { |
| computePassEncoder94.setBindGroup(2, bindGroup12, new Uint32Array(79), 3, 0); |
| } catch {} |
| try { |
| computePassEncoder111.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer34.unmap(); |
| } catch {} |
| let gpuCanvasContext0 = offscreenCanvas1.getContext('webgpu'); |
| let buffer63 = device0.createBuffer({size: 8518, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let texture126 = device0.createTexture({ |
| size: [1, 273, 1], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: true}); |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup22, new Uint32Array(1102), 84, 1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer48, 0); |
| } catch {} |
| let arrayBuffer9 = buffer1.getMappedRange(2584, 8); |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| try { |
| texture45.label = '\u09fd\u0188\u{1fd50}'; |
| } catch {} |
| let renderBundle11 = renderBundleEncoder11.finish(); |
| let sampler68 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMinClamp: 26.37, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup54, new Uint32Array(3457), 796, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer34, 3_352); }; |
| } catch {} |
| try { |
| computePassEncoder2.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let imageData10 = new ImageData(56, 216); |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1, 3, 1); }; |
| } catch {} |
| try { |
| computePassEncoder112.setPipeline(pipeline3); |
| } catch {} |
| let pipeline16 = device0.createRenderPipeline({ |
| layout: pipelineLayout3, |
| fragment: {module: shaderModule4, entryPoint: 'fragment3', constants: {}, targets: [{format: 'bgra8unorm'}]}, |
| vertex: { |
| module: shaderModule5, |
| constants: {5_332: 1}, |
| buffers: [ |
| { |
| arrayStride: 152, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x4', offset: 64, shaderLocation: 12}, |
| {format: 'sint8x2', offset: 22, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 8, shaderLocation: 3}, |
| {format: 'float16x4', offset: 4, shaderLocation: 13}, |
| {format: 'uint32x4', offset: 24, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 16, shaderLocation: 8}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 14}, |
| {format: 'uint32x3', offset: 40, shaderLocation: 7}, |
| {format: 'uint8x2', offset: 14, shaderLocation: 9}, |
| {format: 'snorm16x4', offset: 12, shaderLocation: 11}, |
| {format: 'float32x3', offset: 0, shaderLocation: 1}, |
| {format: 'unorm8x4', offset: 12, shaderLocation: 6}, |
| {format: 'unorm16x4', offset: 24, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 172, |
| stepMode: 'instance', |
| attributes: [{format: 'sint16x4', offset: 0, shaderLocation: 4}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw'}, |
| }); |
| let buffer64 = device0.createBuffer({size: 5339, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let buffer65 = device0.createBuffer({ |
| size: 991, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 733}); |
| let textureView111 = texture45.createView({dimension: '2d'}); |
| try { |
| computePassEncoder114.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView112 = texture95.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 8}); |
| let sampler69 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 76.75, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder109.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| label: '\u{1ff69}\u5ea7\u03f5\u00b9\u7599\u0e95\u021a\u1c3b\u882d', |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 174, resource: {buffer: buffer57, offset: 46080}}], |
| }); |
| let buffer66 = device0.createBuffer({ |
| size: 17704, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder101.setBindGroup(2, bindGroup26, [256]); |
| } catch {} |
| try { |
| computePassEncoder62.insertDebugMarker('\u{1f8b3}'); |
| } catch {} |
| let recycledExplicitBindGroupLayout12 = pipeline5.getBindGroupLayout(0); |
| let texture127 = device0.createTexture({ |
| size: [839], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler70 = device0.createSampler({ |
| label: '\u26e6\ucf2c\ub622\u0169\u26b1\u0ca6\u8e60', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.38, |
| }); |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let imageData11 = new ImageData(12, 28); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let textureView113 = texture52.createView({ |
| label: '\u7669\u0bf4\u02ad\u878a\u0b2a\u0e47\u08dd\u067a\u6fb3\uc5d9\u0be8', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| }); |
| let computePassEncoder115 = commandEncoder103.beginComputePass({label: '\u3cc7\u8137\uee2b\u0ca3'}); |
| let sampler71 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 94.92, |
| }); |
| try { |
| computePassEncoder102.setBindGroup(3, bindGroup54, new Uint32Array(3208), 275, 1); |
| } catch {} |
| try { |
| adapter0.label = '\u5ee8\u0beb'; |
| } catch {} |
| try { |
| externalTexture3.label = '\u{1fe05}\u{1f9bf}\ub342\ue5dd'; |
| } catch {} |
| let buffer67 = device0.createBuffer({ |
| size: 2404, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture128 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView114 = texture123.createView({dimension: '3d'}); |
| let sampler72 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.02, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder71.setBindGroup(0, bindGroup47, [4352]); |
| } catch {} |
| try { |
| computePassEncoder103.setBindGroup(0, bindGroup18, new Uint32Array(2685), 779, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 9156, new DataView(new ArrayBuffer(5241)), 381, 668); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let recycledExplicitBindGroupLayout13 = pipeline6.getBindGroupLayout(0); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let textureView115 = texture69.createView({}); |
| let computePassEncoder116 = commandEncoder104.beginComputePass({}); |
| try { |
| computePassEncoder54.setBindGroup(0, bindGroup16, [0]); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let texture129 = device0.createTexture({ |
| size: {width: 2, height: 1095, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup5, new Uint32Array(195), 59, 0); |
| } catch {} |
| try { |
| computePassEncoder102.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 787, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture119, |
| mipLevel: 1, |
| origin: {x: 0, y: 33, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 79, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 209, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup56 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout8, |
| entries: [{binding: 174, resource: {buffer: buffer3, offset: 0, size: 120}}], |
| }); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: false}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer11, 1_172); }; |
| } catch {} |
| try { |
| computePassEncoder115.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup52, new Uint32Array(475), 194, 1); |
| } catch {} |
| let arrayBuffer10 = buffer1.getMappedRange(120, 20); |
| let buffer68 = device0.createBuffer({ |
| size: 4292, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| let texture130 = device0.createTexture({ |
| size: {width: 1678, height: 1, depthOrArrayLayers: 44}, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder117 = commandEncoder105.beginComputePass({}); |
| let sampler73 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 69.74, compare: 'always'}); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup33, [0]); |
| } catch {} |
| try { |
| computePassEncoder53.setBindGroup(0, bindGroup29, new Uint32Array(284), 102, 1); |
| } catch {} |
| try { |
| computePassEncoder117.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let imageData12 = new ImageData(64, 24); |
| try { |
| adapter0.label = '\udb85\u434f'; |
| } catch {} |
| let buffer69 = device0.createBuffer({ |
| size: 20208, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let textureView116 = texture65.createView({dimension: '2d', aspect: 'stencil-only', mipLevelCount: 1}); |
| let computePassEncoder118 = commandEncoder106.beginComputePass({}); |
| try { |
| computePassEncoder114.setBindGroup(0, bindGroup31, new Uint32Array(934), 32, 1); |
| } catch {} |
| try { |
| computePassEncoder116.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer47, 1_416); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 209, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame14, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 51, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let bindGroup57 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [{binding: 174, resource: {buffer: buffer11, offset: 1024, size: 1180}}], |
| }); |
| let buffer70 = device0.createBuffer({size: 4820, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let textureView117 = texture126.createView({dimension: '2d-array', format: 'rgba8snorm'}); |
| try { |
| computePassEncoder47.setBindGroup(1, bindGroup49, new Uint32Array(19), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(6, buffer47, 1_168, 2_727); |
| } catch {} |
| document.body.prepend(img0); |
| let imageData13 = new ImageData(4, 64); |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'gamma22curve'} }); |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let texture131 = device0.createTexture({ |
| size: {width: 1, height: 136, depthOrArrayLayers: 20}, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder119 = commandEncoder107.beginComputePass(); |
| let sampler74 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 91.78, |
| compare: 'never', |
| maxAnisotropy: 3, |
| }); |
| try { |
| computePassEncoder104.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| computePassEncoder118.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer19, 'uint16', 542, 600); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(4, buffer22, 0, 831); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture122, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(150).fill(2), /* required buffer size: 150 */ |
| {offset: 150}, {width: 839, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let textureView118 = texture36.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder82.setBindGroup(0, bindGroup29, [768]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder114); computePassEncoder114.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| computePassEncoder113.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup40, [0]); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| await buffer46.mapAsync(GPUMapMode.WRITE, 1064, 764); |
| } catch {} |
| try { |
| computePassEncoder87.pushDebugGroup('\u0d01'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| let texture132 = device0.createTexture({size: {width: 419}, dimension: '1d', format: 'rg16uint', usage: GPUTextureUsage.COPY_SRC}); |
| let renderBundle12 = renderBundleEncoder12.finish({label: '\u8d7b\uf304\u74be\u{1f9fd}\u0e63'}); |
| try { |
| computePassEncoder119.setPipeline(pipeline0); |
| } catch {} |
| let pipeline17 = device0.createComputePipeline({layout: pipelineLayout8, compute: {module: shaderModule2, constants: {}}}); |
| offscreenCanvas0.height = 2003; |
| let computePassEncoder120 = commandEncoder108.beginComputePass({}); |
| try { |
| computePassEncoder51.setBindGroup(0, bindGroup15, [512]); |
| } catch {} |
| try { |
| computePassEncoder100.setBindGroup(3, bindGroup13, new Uint32Array(17), 1, 0); |
| } catch {} |
| try { |
| buffer58.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture133 = device0.createTexture({ |
| size: {width: 3357, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder120.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await buffer32.mapAsync(GPUMapMode.WRITE, 0, 5692); |
| } catch {} |
| let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout13]}); |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let computePassEncoder121 = commandEncoder109.beginComputePass({}); |
| try { |
| computePassEncoder121.setPipeline(pipeline5); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup58 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [{binding: 79, resource: textureView73}, {binding: 209, resource: textureView58}], |
| }); |
| try { |
| computePassEncoder90.setPipeline(pipeline6); |
| } catch {} |
| try { |
| computePassEncoder87.popDebugGroup(); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 87, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let buffer71 = device0.createBuffer({ |
| size: 1841, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup43, new Uint32Array(60), 23, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer64, 552); }; |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let texture134 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView119 = texture34.createView({aspect: 'stencil-only'}); |
| try { |
| computePassEncoder80.setBindGroup(0, bindGroup14, [1792]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder41); computePassEncoder41.dispatchWorkgroupsIndirect(buffer47, 3_404); }; |
| } catch {} |
| try { |
| computePassEncoder94.end(); |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline3); |
| } catch {} |
| document.body.prepend(img0); |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 360, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup59 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 202, resource: textureView0}, {binding: 47, resource: textureView77}], |
| }); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], stencilReadOnly: true}); |
| let renderBundle13 = renderBundleEncoder13.finish(); |
| try { |
| await buffer10.mapAsync(GPUMapMode.READ, 0, 664); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToBuffer(buffer62, 1264, buffer35, 2060, 88); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| try { |
| adapter0.label = '\u6af8\u4f0d\u1dc8\uf1db\u06b8\u{1f613}\u2e5a\u1a48\u48c6\u54a5\u8001'; |
| } catch {} |
| let commandBuffer12 = commandEncoder81.finish(); |
| let computePassEncoder122 = commandEncoder111.beginComputePass({}); |
| try { |
| computePassEncoder39.setBindGroup(0, bindGroup48, new Uint32Array(1008), 32, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 130 widthInBlocks: 65 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1906 */ |
| offset: 1906, |
| bytesPerRow: 4096, |
| buffer: buffer23, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 74, y: 10, z: 10}, |
| aspect: 'all', |
| }, {width: 65, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder122.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12]); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(33, 56); |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 140, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture135 = device0.createTexture({ |
| size: {width: 1, height: 136, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder123 = commandEncoder110.beginComputePass({}); |
| let sampler75 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMinClamp: 80.95, lodMaxClamp: 81.18}); |
| try { |
| computePassEncoder107.end(); |
| } catch {} |
| try { |
| computePassEncoder123.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder112.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 800 */ |
| offset: 800, |
| bytesPerRow: 30976, |
| buffer: buffer19, |
| }, { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 0, y: 98, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 120, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline18 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment2', |
| targets: [{format: 'bgra8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 148, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x4', offset: 8, shaderLocation: 8}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'front'}, |
| }); |
| let imageData14 = new ImageData(88, 20); |
| try { |
| offscreenCanvas2.getContext('webgpu'); |
| } catch {} |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let computePassEncoder124 = commandEncoder94.beginComputePass({}); |
| try { |
| computePassEncoder98.setBindGroup(2, bindGroup32, [256]); |
| } catch {} |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup10, new Uint32Array(996), 640, 1); |
| } catch {} |
| try { |
| computePassEncoder39.end(); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 100, new BigUint64Array(12707), 806, 124); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout9, |
| entries: [{binding: 174, resource: {buffer: buffer17, offset: 0, size: 3328}}], |
| }); |
| let textureView120 = texture60.createView({format: 'r16sint', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder67.setBindGroup(0, bindGroup16, [256]); |
| } catch {} |
| try { |
| computePassEncoder123.setBindGroup(0, bindGroup16, new Uint32Array(951), 136, 1); |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline6); |
| } catch {} |
| try { |
| computePassEncoder124.setPipeline(pipeline1); |
| } catch {} |
| let adapter1 = await promise0; |
| try { |
| computePassEncoder86.setBindGroup(0, bindGroup44, new Uint32Array(1379), 102, 1); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let videoFrame16 = new VideoFrame(videoFrame7, {timestamp: 0}); |
| let querySet16 = device0.createQuerySet({type: 'occlusion', count: 888}); |
| let textureView121 = texture116.createView({dimension: '2d-array'}); |
| let sampler76 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 52.64}); |
| let textureView122 = texture58.createView({dimension: '2d', format: 'stencil8', baseMipLevel: 3, mipLevelCount: 2}); |
| let computePassEncoder125 = commandEncoder112.beginComputePass({}); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup44, new Uint32Array(1687), 77, 1); |
| } catch {} |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 787, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 8, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture96, |
| mipLevel: 1, |
| origin: {x: 0, y: 206, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let bindGroup61 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer53, offset: 6656, size: 2572}}], |
| }); |
| let buffer72 = device0.createBuffer({ |
| size: 11424, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture136 = device0.createTexture({ |
| size: {width: 1, height: 136, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder126 = commandEncoder21.beginComputePass(); |
| let sampler77 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 77.55, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup37, new Uint32Array(567), 122, 0); |
| } catch {} |
| try { |
| computePassEncoder75.end(); |
| } catch {} |
| try { |
| commandEncoder113.clearBuffer(buffer13, 148, 36); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| let textureView123 = texture136.createView({baseMipLevel: 0}); |
| let texture137 = device0.createTexture({ |
| size: {width: 1, height: 136, depthOrArrayLayers: 1}, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let arrayBuffer11 = buffer1.getMappedRange(536, 0); |
| try { |
| device0.queue.writeBuffer(buffer45, 296, new BigUint64Array(1191), 67, 0); |
| } catch {} |
| let texture138 = device0.createTexture({ |
| size: {width: 3357}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView124 = texture129.createView({dimension: '2d-array', format: 'bgra8unorm', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder127 = commandEncoder51.beginComputePass({}); |
| try { |
| commandEncoder114.copyBufferToTexture({ |
| /* bytesInLastRow: 2200 widthInBlocks: 275 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 480 */ |
| offset: 480, |
| buffer: buffer52, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 574, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 275, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder37.clearBuffer(buffer23, 18432); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let textureView125 = texture138.createView({}); |
| let textureView126 = texture17.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder128 = commandEncoder114.beginComputePass({}); |
| try { |
| computePassEncoder93.setBindGroup(0, bindGroup44, new Uint32Array(876), 58, 1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline19 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment5', |
| constants: {35_410: 1}, |
| targets: [{format: 'rg16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: {module: shaderModule6, constants: {}, buffers: []}, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let computePassEncoder129 = commandEncoder37.beginComputePass(); |
| let sampler78 = device0.createSampler({addressModeU: 'mirror-repeat'}); |
| try { |
| computePassEncoder117.setBindGroup(0, bindGroup54, [0]); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 108 */ |
| offset: 108, |
| buffer: buffer14, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture46, |
| mipLevel: 1, |
| origin: {x: 33, y: 13, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(338).fill(170), /* required buffer size: 338 */ |
| {offset: 332}, {width: 3, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'linear'} }); |
| let commandEncoder117 = device0.createCommandEncoder({label: '\ua37f\u39ac'}); |
| let texture139 = device0.createTexture({ |
| size: [1, 136, 41], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16uint'], |
| }); |
| let textureView127 = texture133.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let renderPassEncoder0 = commandEncoder117.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView124, |
| clearValue: { r: -438.8, g: 544.6, b: -29.13, a: 909.2, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder96.setBindGroup(0, bindGroup44, [512]); |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer42, 'uint16', 5_680, 397); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer16, 0, 468); |
| } catch {} |
| try { |
| buffer26.unmap(); |
| } catch {} |
| try { |
| commandEncoder116.copyTextureToTexture({ |
| texture: texture33, |
| mipLevel: 1, |
| origin: {x: 0, y: 104, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture62, |
| mipLevel: 3, |
| origin: {x: 0, y: 18, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 31, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 4, height: 1575, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture96, |
| mipLevel: 0, |
| origin: {x: 0, y: 506, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer73 = device0.createBuffer({ |
| size: 65536, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder130 = commandEncoder115.beginComputePass(); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer67, 216, 168); |
| } catch {} |
| document.body.append(img0); |
| let buffer74 = device0.createBuffer({ |
| size: 2947, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let querySet17 = device0.createQuerySet({type: 'occlusion', count: 955}); |
| let textureView128 = texture136.createView({}); |
| let computePassEncoder131 = commandEncoder116.beginComputePass({}); |
| try { |
| renderPassEncoder0.beginOcclusionQuery(2); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer40, 904); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer54, 48, new DataView(new ArrayBuffer(4244)), 2041, 464); |
| } catch {} |
| await gc(); |
| let bindGroup62 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout11, |
| entries: [{binding: 174, resource: {buffer: buffer56, offset: 1536}}], |
| }); |
| let textureView129 = texture60.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer25, 64); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer28, 0); |
| } catch {} |
| try { |
| canvas0.getContext('bitmaprenderer'); |
| } catch {} |
| let buffer75 = device0.createBuffer({size: 17473, usage: GPUBufferUsage.MAP_WRITE}); |
| let querySet18 = device0.createQuerySet({type: 'occlusion', count: 616}); |
| try { |
| computePassEncoder109.setBindGroup(3, bindGroup27, [512]); |
| } catch {} |
| try { |
| commandEncoder113.clearBuffer(buffer7, 2464, 640); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture140 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView130 = texture96.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| computePassEncoder110.setBindGroup(0, bindGroup25, new Uint32Array(1995), 249, 0); |
| } catch {} |
| try { |
| computePassEncoder125.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup39, new Uint32Array(94), 7, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer40, 'uint32', 4_668, 57); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer40, 64); |
| } catch {} |
| try { |
| buffer62.unmap(); |
| } catch {} |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let querySet19 = device0.createQuerySet({type: 'occlusion', count: 794}); |
| let textureView131 = texture138.createView({format: 'rg32float'}); |
| try { |
| computePassEncoder80.setBindGroup(0, bindGroup9, new Uint32Array(4335), 60, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder62); computePassEncoder62.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder51); computePassEncoder51.dispatchWorkgroupsIndirect(buffer55, 3_124); }; |
| } catch {} |
| try { |
| computePassEncoder127.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 2288 */ |
| offset: 2288, |
| bytesPerRow: 39680, |
| rowsPerImage: 177, |
| buffer: buffer50, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 0, y: 18, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder113.clearBuffer(buffer10, 196, 20); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer33, 4800, new BigUint64Array(34351), 2414, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture112, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(26).fill(116), /* required buffer size: 26 */ |
| {offset: 26, bytesPerRow: 97, rowsPerImage: 560}, {width: 1, height: 547, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let textureView132 = texture3.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 3, arrayLayerCount: 6}); |
| let computePassEncoder132 = commandEncoder113.beginComputePass({}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup52, [1024]); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup15, new Uint32Array(2453), 558, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer66, 2_220); |
| } catch {} |
| try { |
| commandEncoder119.copyBufferToBuffer(buffer52, 504, buffer58, 4708, 380); |
| } catch {} |
| let bindGroup63 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 34, resource: textureView86}, |
| {binding: 14, resource: sampler69}, |
| {binding: 28, resource: textureView42}, |
| {binding: 495, resource: {buffer: buffer17, offset: 4352, size: 1356}}, |
| ], |
| }); |
| let commandEncoder120 = device0.createCommandEncoder(); |
| let computePassEncoder133 = commandEncoder120.beginComputePass({}); |
| let sampler79 = device0.createSampler({addressModeW: 'mirror-repeat'}); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder95.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder0.setBlendConstant({ r: 814.2, g: -673.4, b: 888.5, a: -840.3, }); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder0.insertDebugMarker('\ufbe8'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let pipeline20 = await promise1; |
| let promise17 = device0.createRenderPipelineAsync({ |
| layout: pipelineLayout7, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment5', |
| constants: {35_410: 1}, |
| targets: [{format: 'rg16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: {module: shaderModule3, buffers: []}, |
| primitive: {frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| let computePassEncoder134 = commandEncoder118.beginComputePass(); |
| try { |
| computePassEncoder67.setBindGroup(0, bindGroup33, new Uint32Array(992), 42, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup31, new Uint32Array(2054), 463, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer14, 'uint16', 6_478, 1_693); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer21); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| let device1 = await adapter1.requestDevice({ |
| defaultQueue: {}, |
| requiredLimits: { |
| minUniformBufferOffsetAlignment: 256, |
| maxUniformBufferBindingSize: 74444816, |
| maxStorageBufferBindingSize: 158637421, |
| }, |
| }); |
| try { |
| adapter1.label = '\u5c19\ue282'; |
| } catch {} |
| let texture141 = device0.createTexture({ |
| size: [256, 256, 21], |
| mipLevelCount: 2, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| buffer49.unmap(); |
| } catch {} |
| try { |
| commandEncoder121.copyBufferToBuffer(buffer69, 1636, buffer42, 6944, 664); |
| } catch {} |
| try { |
| commandEncoder121.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1560 */ |
| offset: 1560, |
| bytesPerRow: 49408, |
| buffer: buffer44, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline21 = await promise17; |
| let bindGroup64 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [{binding: 174, resource: {buffer: buffer25, offset: 512, size: 748}}], |
| }); |
| let texture142 = device0.createTexture({ |
| size: [419, 1, 7], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder135 = commandEncoder119.beginComputePass({label: '\u0e90\ub7f9\u0be8\uae4d\uc180\u09c5\ub6b4'}); |
| try { |
| computePassEncoder22.setBindGroup(1, bindGroup8, new Uint32Array(3105), 172, 0); |
| } catch {} |
| try { |
| computePassEncoder132.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer27, 'uint16', 2_406, 29); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder121.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 598 */ |
| offset: 598, |
| bytesPerRow: 20736, |
| buffer: buffer56, |
| }, { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 1, y: 139, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 351, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder121.insertDebugMarker('\u52c0'); |
| } catch {} |
| try { |
| computePassEncoder5.insertDebugMarker('\u{1f672}'); |
| } catch {} |
| let pipeline22 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule3, constants: {}}}); |
| let imageData15 = new ImageData(172, 68); |
| let bindGroup65 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 47, resource: textureView8}, {binding: 202, resource: textureView59}], |
| }); |
| let texture143 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView133 = texture40.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder136 = commandEncoder121.beginComputePass({}); |
| try { |
| computePassEncoder30.end(); |
| } catch {} |
| try { |
| computePassEncoder135.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup50, [256]); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup54, new Uint32Array(976), 248, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.end(); |
| } catch {} |
| try { |
| commandEncoder30.copyTextureToBuffer({ |
| texture: texture43, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, { |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 424 */ |
| offset: 424, |
| bytesPerRow: 14080, |
| rowsPerImage: 338, |
| buffer: buffer17, |
| }, {width: 1, height: 273, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let buffer76 = device1.createBuffer({size: 1168, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let commandEncoder122 = device1.createCommandEncoder({}); |
| let computePassEncoder137 = commandEncoder122.beginComputePass({}); |
| document.body.append(canvas0); |
| let computePassEncoder138 = commandEncoder30.beginComputePass({}); |
| try { |
| computePassEncoder124.setBindGroup(0, bindGroup33, new Uint32Array(884), 55, 1); |
| } catch {} |
| try { |
| computePassEncoder133.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder117.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2888 */ |
| offset: 2888, |
| bytesPerRow: 24320, |
| buffer: buffer35, |
| }, { |
| texture: texture96, |
| mipLevel: 2, |
| origin: {x: 0, y: 147, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let sampler80 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 93.89, |
| compare: 'greater-equal', |
| }); |
| let sampler81 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 90.98, |
| maxAnisotropy: 1, |
| }); |
| let sampler82 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 68.37, |
| maxAnisotropy: 10, |
| }); |
| try { |
| buffer76.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout17 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 106, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 162, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 454, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer77 = device1.createBuffer({ |
| size: 20385, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder123 = device1.createCommandEncoder({}); |
| let texture144 = device1.createTexture({ |
| size: {width: 2240, height: 40, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder139 = commandEncoder123.beginComputePass({}); |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| let buffer78 = device1.createBuffer({size: 1547, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView134 = texture144.createView({}); |
| let commandEncoder124 = device0.createCommandEncoder(); |
| let texture145 = device0.createTexture({ |
| size: [839], |
| dimension: '1d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder68.setBindGroup(0, bindGroup50, new Uint32Array(358), 37, 1); |
| } catch {} |
| try { |
| computePassEncoder128.setPipeline(pipeline15); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let texture146 = device0.createTexture({ |
| size: {width: 1678, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView135 = texture46.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 4}); |
| let computePassEncoder140 = commandEncoder124.beginComputePass({}); |
| try { |
| computePassEncoder82.setBindGroup(0, bindGroup7, [0]); |
| } catch {} |
| try { |
| computePassEncoder140.setPipeline(pipeline3); |
| } catch {} |
| let promise19 = device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment3', |
| constants: {}, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| vertex: {module: shaderModule4, entryPoint: 'vertex4', buffers: []}, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front'}, |
| }); |
| await gc(); |
| let textureView136 = texture144.createView({baseMipLevel: 0}); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 130, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(172).fill(233), /* required buffer size: 172 */ |
| {offset: 172, bytesPerRow: 721}, {width: 172, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 106, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 162, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 454, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder137.pushDebugGroup('\u0341'); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer78, 196, new Int16Array(35441), 2394, 160); |
| } catch {} |
| let texture147 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder141 = commandEncoder117.beginComputePass({}); |
| let sampler83 = device0.createSampler({addressModeV: 'mirror-repeat', lodMaxClamp: 81.52, compare: 'never'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder74); computePassEncoder74.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder131.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder125.copyBufferToBuffer(buffer50, 980, buffer35, 9804, 3952); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(468_606).fill(51), /* required buffer size: 468_606 */ |
| {offset: 89, bytesPerRow: 423, rowsPerImage: 284}, {width: 256, height: 256, depthOrArrayLayers: 4}); |
| } catch {} |
| let pipelineLayout12 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout17]}); |
| let buffer79 = device1.createBuffer({size: 10208, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder126 = device1.createCommandEncoder({}); |
| let computePassEncoder142 = commandEncoder126.beginComputePass({}); |
| try { |
| computePassEncoder137.popDebugGroup(); |
| } catch {} |
| let promise20 = device1.queue.onSubmittedWorkDone(); |
| let offscreenCanvas3 = new OffscreenCanvas(221, 102); |
| let bindGroup66 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [{binding: 87, resource: {buffer: buffer25, offset: 512, size: 1948}}], |
| }); |
| let textureView137 = texture96.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 2}); |
| try { |
| computePassEncoder136.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 7, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture146, |
| mipLevel: 2, |
| origin: {x: 64, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let pipelineLayout13 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout18]}); |
| let querySet20 = device1.createQuerySet({type: 'occlusion', count: 728}); |
| let sampler84 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 99.71, compare: 'less'}); |
| let gpuCanvasContext1 = offscreenCanvas3.getContext('webgpu'); |
| try { |
| await promise18; |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 106, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 162, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 454, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer80 = device0.createBuffer({ |
| label: '\u564c\ud9d3\ud7ab\ud1e1\u00eb\u64db\u047d\u{1fa8b}\u1b57\u0ad2\u7484', |
| size: 9762, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| let computePassEncoder143 = commandEncoder125.beginComputePass({}); |
| try { |
| computePassEncoder143.setBindGroup(1, bindGroup60, [1024]); |
| } catch {} |
| try { |
| computePassEncoder126.setPipeline(pipeline17); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 21} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 30, y: 10, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| let texture148 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder144 = commandEncoder128.beginComputePass({}); |
| try { |
| computePassEncoder105.setBindGroup(1, bindGroup13, new Uint32Array(2380), 135, 0); |
| } catch {} |
| try { |
| computePassEncoder143.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder127.copyTextureToTexture({ |
| texture: texture95, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 0, y: 231, z: 86}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| document.body.append(img0); |
| let buffer81 = device0.createBuffer({size: 1243, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder129 = device0.createCommandEncoder(); |
| let texture149 = device0.createTexture({ |
| size: [419, 1, 52], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder145 = commandEncoder129.beginComputePass({}); |
| let renderPassEncoder1 = commandEncoder127.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView130, |
| clearValue: { r: -727.3, g: -334.5, b: 850.6, a: 221.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer27, 'uint32', 40, 1_078); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 4, new Float32Array(36885), 17189, 192); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 291, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(96).fill(144), /* required buffer size: 96 */ |
| {offset: 96}, {width: 85, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView138 = texture3.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 6}); |
| try { |
| computePassEncoder129.setPipeline(pipeline22); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| await gc(); |
| let textureView139 = texture90.createView({baseArrayLayer: 4, arrayLayerCount: 1}); |
| try { |
| computePassEncoder114.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer7, 'uint32', 264, 117); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer67, 88, 438); |
| } 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 {} |
| document.body.prepend(canvas0); |
| let imageData16 = new ImageData(56, 4); |
| let buffer82 = device1.createBuffer({size: 11168, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let commandEncoder130 = device1.createCommandEncoder({}); |
| let textureView140 = texture144.createView({dimension: '2d-array', format: 'r32sint', baseArrayLayer: 0}); |
| let sampler85 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 60.55, |
| }); |
| await gc(); |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte170m', transfer: 'bt709'} }); |
| let commandBuffer13 = commandEncoder28.finish(); |
| let texture150 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let bindGroup67 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 70, resource: {buffer: buffer14, offset: 1792, size: 1187}}, |
| {binding: 116, resource: {buffer: buffer72, offset: 256}}, |
| ], |
| }); |
| let commandEncoder131 = device0.createCommandEncoder(); |
| let computePassEncoder146 = commandEncoder131.beginComputePass({}); |
| try { |
| computePassEncoder134.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup63, new Uint32Array(1279), 213, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(1, 129, 0, 892); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline16); |
| } catch {} |
| let pipeline23 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment3', |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'src-alpha-saturated'}, |
| alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'src-alpha-saturated'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule5, |
| buffers: [ |
| { |
| arrayStride: 140, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm8x4', offset: 28, shaderLocation: 14}, |
| {format: 'float32x2', offset: 4, shaderLocation: 8}, |
| {format: 'float16x4', offset: 20, shaderLocation: 3}, |
| {format: 'uint32x3', offset: 12, shaderLocation: 15}, |
| {format: 'sint8x2', offset: 52, shaderLocation: 4}, |
| {format: 'float32x2', offset: 56, shaderLocation: 6}, |
| {format: 'sint8x4', offset: 12, shaderLocation: 10}, |
| {format: 'uint16x4', offset: 68, shaderLocation: 7}, |
| {format: 'float32x3', offset: 16, shaderLocation: 13}, |
| {format: 'snorm8x2', offset: 14, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 348, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x2', offset: 44, shaderLocation: 11}, |
| {format: 'uint16x2', offset: 44, shaderLocation: 9}, |
| {format: 'float32x2', offset: 184, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'front'}, |
| }); |
| let commandEncoder132 = device1.createCommandEncoder({}); |
| let texture151 = device1.createTexture({ |
| size: [1810, 1, 439], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView141 = texture144.createView({}); |
| document.body.append(img0); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let texture152 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView142 = texture144.createView({dimension: '2d-array'}); |
| let computePassEncoder147 = commandEncoder130.beginComputePass({}); |
| let sampler86 = device1.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.43, |
| maxAnisotropy: 15, |
| }); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let pipelineLayout14 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout17]}); |
| let sampler87 = device1.createSampler({lodMaxClamp: 97.50, compare: 'greater-equal'}); |
| let sampler88 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 16, |
| }); |
| try { |
| device1.queue.writeBuffer(buffer77, 2280, new BigUint64Array(3988), 167, 1216); |
| } catch {} |
| let commandEncoder133 = device0.createCommandEncoder({}); |
| let texture153 = device0.createTexture({size: {width: 1}, dimension: '1d', format: 'rg16uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView143 = texture43.createView({aspect: 'stencil-only', mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder148 = commandEncoder133.beginComputePass(); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup26, [256]); |
| } catch {} |
| try { |
| computePassEncoder77.setBindGroup(2, bindGroup23, new Uint32Array(3677), 301, 0); |
| } catch {} |
| try { |
| computePassEncoder141.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer57, 'uint16', 31_310, 2_467); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(6, buffer66, 0); |
| } catch {} |
| let pipeline24 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule2, constants: {}}}); |
| let offscreenCanvas4 = new OffscreenCanvas(83, 23); |
| let commandEncoder134 = device1.createCommandEncoder(); |
| let computePassEncoder149 = commandEncoder134.beginComputePass({}); |
| let renderBundleEncoder14 = device1.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| try { |
| commandEncoder132.copyTextureToBuffer({ |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 429, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 432 widthInBlocks: 108 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 388 */ |
| offset: 388, |
| bytesPerRow: 14592, |
| buffer: buffer77, |
| }, {width: 108, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder14.insertDebugMarker('\ubc41'); |
| } catch {} |
| await gc(); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let computePassEncoder150 = commandEncoder135.beginComputePass({}); |
| try { |
| computePassEncoder119.setBindGroup(0, bindGroup36, [1792]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer55, 'uint16', 6_360, 247); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 26, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 45, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer83 = device1.createBuffer({ |
| size: 1585, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture154 = device1.createTexture({ |
| size: {width: 8}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView144 = texture144.createView({dimension: '2d-array'}); |
| let computePassEncoder151 = commandEncoder132.beginComputePass({}); |
| let renderBundle14 = renderBundleEncoder14.finish({}); |
| let gpuCanvasContext2 = offscreenCanvas4.getContext('webgpu'); |
| try { |
| device1.label = '\u0460\ue32a'; |
| } catch {} |
| let commandEncoder136 = device1.createCommandEncoder({}); |
| let textureView145 = texture154.createView({}); |
| try { |
| commandEncoder136.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 216 */ |
| offset: 216, |
| bytesPerRow: 35072, |
| buffer: buffer83, |
| }, { |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 106, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 162, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 454, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder137 = device1.createCommandEncoder(); |
| let computePassEncoder152 = commandEncoder137.beginComputePass({}); |
| document.body.prepend(img0); |
| let querySet21 = device1.createQuerySet({type: 'occlusion', count: 382}); |
| let texture155 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView146 = texture154.createView({arrayLayerCount: 1}); |
| let computePassEncoder153 = commandEncoder136.beginComputePass(); |
| try { |
| buffer82.unmap(); |
| } catch {} |
| let bindGroup68 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 87, resource: {buffer: buffer27, offset: 0, size: 1340}}], |
| }); |
| let buffer84 = device0.createBuffer({ |
| size: 31378, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView147 = texture42.createView({aspect: 'all'}); |
| try { |
| computePassEncoder44.setBindGroup(0, bindGroup21, new Uint32Array(619), 62, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder93); computePassEncoder93.dispatchWorkgroupsIndirect(buffer26, 548); }; |
| } catch {} |
| try { |
| computePassEncoder138.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 680, new Float32Array(4261), 591, 412); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup69 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 34, resource: textureView99}, |
| {binding: 495, resource: {buffer: buffer17, offset: 0, size: 2420}}, |
| {binding: 28, resource: textureView126}, |
| {binding: 14, resource: sampler29}, |
| ], |
| }); |
| let buffer85 = device0.createBuffer({size: 1034, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture156 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler89 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 94.70}); |
| try { |
| computePassEncoder35.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder146.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup18, [512]); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u12cd'); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [{binding: 174, resource: {buffer: buffer67, offset: 0, size: 528}}], |
| }); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let texture157 = device0.createTexture({ |
| size: {width: 839}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder2 = commandEncoder138.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView130, |
| clearValue: { r: 758.5, g: 37.77, b: 495.6, a: 267.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler90 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 98.51, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder66.setBindGroup(0, bindGroup64, [0]); |
| } catch {} |
| try { |
| computePassEncoder56.end(); |
| } catch {} |
| try { |
| computePassEncoder130.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup51, [512]); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| let texture158 = device0.createTexture({ |
| size: {width: 1, height: 136, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView148 = texture10.createView({dimension: '2d'}); |
| let computePassEncoder154 = commandEncoder53.beginComputePass(); |
| try { |
| computePassEncoder120.setBindGroup(0, bindGroup21, new Uint32Array(472), 129, 1); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup18, [0]); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| await buffer18.mapAsync(GPUMapMode.READ, 1360, 196); |
| } catch {} |
| try { |
| commandEncoder139.copyTextureToTexture({ |
| texture: texture112, |
| mipLevel: 1, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 55, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture159 = device1.createTexture({ |
| size: [1120], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture160 = device1.createTexture({ |
| size: {width: 528, height: 40, depthOrArrayLayers: 4}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let promise22 = device1.queue.onSubmittedWorkDone(); |
| let buffer86 = device1.createBuffer({ |
| size: 7045, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture161 = device1.createTexture({ |
| size: {width: 528, height: 40, depthOrArrayLayers: 98}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32uint'], |
| }); |
| let textureView149 = texture154.createView({}); |
| let textureView150 = texture129.createView({dimension: '2d-array', format: 'bgra8unorm', mipLevelCount: 1}); |
| let computePassEncoder155 = commandEncoder139.beginComputePass({}); |
| try { |
| computePassEncoder113.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup52, new Uint32Array(117), 46, 1); |
| } catch {} |
| try { |
| computePassEncoder150.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup10, [2048]); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup44, new Uint32Array(881), 166, 1); |
| } catch {} |
| let arrayBuffer12 = buffer32.getMappedRange(80, 732); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img0); |
| let pipelineLayout15 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout19]}); |
| let texture162 = device1.createTexture({ |
| size: {width: 1120, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| gpuCanvasContext1.configure({device: device1, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture151, |
| mipLevel: 1, |
| origin: {x: 33, y: 0, z: 18}, |
| aspect: 'all', |
| }, new Uint8Array(77_179).fill(183), /* required buffer size: 77_179 */ |
| {offset: 256, bytesPerRow: 189, rowsPerImage: 37}, {width: 33, height: 0, depthOrArrayLayers: 12}); |
| } catch {} |
| let offscreenCanvas5 = new OffscreenCanvas(123, 110); |
| let commandEncoder140 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder115.setBindGroup(2, bindGroup43, new Uint32Array(3067), 134, 0); |
| } catch {} |
| let pipelineLayout16 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout18]}); |
| let buffer87 = device1.createBuffer({size: 8654, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let buffer88 = device1.createBuffer({size: 1623, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| try { |
| await promise22; |
| } catch {} |
| await gc(); |
| let bindGroup71 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer64, offset: 0, size: 4224}}, |
| {binding: 70, resource: {buffer: buffer25, offset: 512, size: 1096}}, |
| ], |
| }); |
| let texture163 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 103}, |
| dimension: '3d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer84, 140); }; |
| } catch {} |
| try { |
| computePassEncoder148.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup17, new Uint32Array(676), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle9, renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, undefined, 205_365_235); |
| } catch {} |
| try { |
| commandEncoder127.copyBufferToBuffer(buffer19, 1520, buffer44, 1208, 760); |
| } catch {} |
| try { |
| commandEncoder127.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2054 */ |
| offset: 2054, |
| bytesPerRow: 23040, |
| buffer: buffer62, |
| }, { |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 0, y: 39, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(52).fill(123), /* required buffer size: 52 */ |
| {offset: 52}, {width: 85, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup72 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout17, |
| entries: [ |
| {binding: 106, resource: {buffer: buffer86, offset: 768, size: 2116}}, |
| {binding: 162, resource: {buffer: buffer86, offset: 2816, size: 1024}}, |
| {binding: 21, resource: textureView134}, |
| {binding: 454, resource: {buffer: buffer86, offset: 256, size: 832}}, |
| ], |
| }); |
| let commandEncoder141 = device1.createCommandEncoder(); |
| let texture164 = device1.createTexture({ |
| size: [2, 160, 34], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder149.setBindGroup(1, bindGroup72, [0]); |
| } catch {} |
| try { |
| commandEncoder141.copyTextureToTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 188, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let textureView151 = texture10.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| computePassEncoder155.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup7, [1024]); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let arrayBuffer13 = buffer46.getMappedRange(1064, 8); |
| try { |
| adapter1.label = '\u9100\u0795\u0dd6\u{1f605}\ufbe3\u{1fd89}'; |
| } catch {} |
| let commandEncoder142 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder153.setBindGroup(0, bindGroup72, [1792]); |
| } catch {} |
| try { |
| commandEncoder141.clearBuffer(buffer82); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer89 = device0.createBuffer({ |
| size: 14427, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| let texture165 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView152 = texture88.createView({arrayLayerCount: 5}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer14, 'uint32', 2_972, 12); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer21, offset: 0, size: 9188}}], |
| }); |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let querySet22 = device0.createQuerySet({type: 'occlusion', count: 152}); |
| let commandBuffer14 = commandEncoder127.finish(); |
| let computePassEncoder156 = commandEncoder140.beginComputePass({}); |
| try { |
| computePassEncoder120.setPipeline(pipeline11); |
| } catch {} |
| try { |
| computePassEncoder145.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle9, renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer26, 'uint16', 276, 1_093); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer80); |
| } catch {} |
| try { |
| commandEncoder144.copyBufferToBuffer(buffer49, 3064, buffer45, 292, 16); |
| } catch {} |
| try { |
| commandEncoder144.copyTextureToBuffer({ |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 67, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 3416 widthInBlocks: 427 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 8 */ |
| offset: 8, |
| buffer: buffer58, |
| }, {width: 427, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder144.resolveQuerySet(querySet13, 0, 1, buffer42, 3584); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [{binding: 174, resource: {buffer: buffer68, offset: 256}}], |
| }); |
| let computePassEncoder157 = commandEncoder144.beginComputePass({}); |
| let sampler91 = device0.createSampler({addressModeV: 'mirror-repeat'}); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup61, [256]); |
| } catch {} |
| let arrayBuffer14 = buffer32.getMappedRange(816, 1152); |
| try { |
| device0.queue.writeBuffer(buffer80, 108, new Float32Array(51347), 5120, 288); |
| } catch {} |
| let commandEncoder145 = device0.createCommandEncoder(); |
| let querySet23 = device0.createQuerySet({type: 'occlusion', count: 998}); |
| try { |
| commandEncoder143.copyTextureToTexture({ |
| texture: texture36, |
| mipLevel: 1, |
| origin: {x: 0, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture46, |
| mipLevel: 1, |
| origin: {x: 9, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 83, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| document.body.prepend(canvas1); |
| let computePassEncoder158 = commandEncoder141.beginComputePass({}); |
| let sampler92 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.12, |
| }); |
| try { |
| commandEncoder142.copyBufferToTexture({ |
| /* bytesInLastRow: 1360 widthInBlocks: 340 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 428 */ |
| offset: 428, |
| bytesPerRow: 14592, |
| buffer: buffer83, |
| }, { |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 977, y: 12, z: 0}, |
| aspect: 'all', |
| }, {width: 340, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| externalTexture1.label = '\uca9f\u{1fde9}\u0ce9\u{1fefb}\u9615\u0621'; |
| } catch {} |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| let textureView153 = texture53.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder154.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer22, 'uint32', 400, 562); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 1, y: 10 }, |
| flipY: false, |
| }, { |
| texture: texture129, |
| mipLevel: 1, |
| origin: {x: 0, y: 16, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let computePassEncoder159 = commandEncoder142.beginComputePass({}); |
| let sampler93 = device1.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 73.91, |
| compare: 'never', |
| maxAnisotropy: 13, |
| }); |
| let commandEncoder147 = device1.createCommandEncoder({}); |
| let querySet24 = device1.createQuerySet({type: 'occlusion', count: 1624}); |
| let commandBuffer15 = commandEncoder147.finish(); |
| try { |
| computePassEncoder142.setBindGroup(1, bindGroup72, [0]); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device1.queue.submit([commandBuffer15]); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| canvas0.height = 2093; |
| let commandEncoder148 = device1.createCommandEncoder({}); |
| let computePassEncoder160 = commandEncoder148.beginComputePass({}); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(76).fill(160), /* required buffer size: 76 */ |
| {offset: 76, bytesPerRow: 31}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let computePassEncoder161 = commandEncoder145.beginComputePass({}); |
| try { |
| computePassEncoder87.setBindGroup(0, bindGroup36, new Uint32Array(622), 63, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder93.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup33, [768]); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| commandEncoder149.copyBufferToBuffer(buffer72, 4104, buffer17, 2608, 524); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup75 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 21, resource: textureView136}, |
| {binding: 454, resource: {buffer: buffer86, offset: 0, size: 1670}}, |
| {binding: 162, resource: {buffer: buffer86, offset: 768, size: 1432}}, |
| {binding: 106, resource: {buffer: buffer86, offset: 768, size: 1936}}, |
| ], |
| }); |
| let commandEncoder150 = device1.createCommandEncoder(); |
| let computePassEncoder162 = commandEncoder150.beginComputePass({}); |
| try { |
| await promise23; |
| } catch {} |
| let textureView154 = texture144.createView({}); |
| try { |
| computePassEncoder142.setBindGroup(3, bindGroup72, new Uint32Array(2007), 67, 1); |
| } catch {} |
| try { |
| buffer77.unmap(); |
| } catch {} |
| let texture166 = device0.createTexture({size: [1678], sampleCount: 1, dimension: '1d', format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder163 = commandEncoder146.beginComputePass({}); |
| let renderPassEncoder3 = commandEncoder83.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView150, |
| clearValue: { r: -763.8, g: 584.1, b: 21.38, a: -124.2, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| computePassEncoder34.end(); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| await gc(); |
| let texture167 = device1.createTexture({ |
| size: {width: 132, height: 10, depthOrArrayLayers: 4}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView155 = texture154.createView({format: 'rg32uint'}); |
| try { |
| computePassEncoder139.setBindGroup(1, bindGroup72, [0]); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture151, |
| mipLevel: 2, |
| origin: {x: 15, y: 0, z: 10}, |
| aspect: 'all', |
| }, new Uint8Array(204_750).fill(158), /* required buffer size: 204_750 */ |
| {offset: 405, bytesPerRow: 239, rowsPerImage: 15}, {width: 28, height: 0, depthOrArrayLayers: 58}); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer90 = device0.createBuffer({ |
| size: 10067, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder151 = device0.createCommandEncoder(); |
| let commandBuffer16 = commandEncoder35.finish({}); |
| try { |
| computePassEncoder106.setBindGroup(0, bindGroup48, [512]); |
| } catch {} |
| try { |
| computePassEncoder108.setBindGroup(0, bindGroup56, new Uint32Array(222), 19, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer64, 1_060); }; |
| } catch {} |
| try { |
| computePassEncoder144.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer31, 'uint32', 740, 36); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer42, 0, 1_618); |
| } catch {} |
| try { |
| commandEncoder143.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2944 */ |
| offset: 2944, |
| buffer: buffer60, |
| }, { |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 0, y: 52, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device1.queue.label = '\u{1fa4b}\u0b7e\ud91a\u154c\u254d\u1e39\u072d\ue093\uc3d5\u03c5'; |
| } catch {} |
| let commandEncoder152 = device1.createCommandEncoder({}); |
| let sampler94 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 67.32, |
| }); |
| try { |
| computePassEncoder158.setBindGroup(0, bindGroup75, [1280]); |
| } catch {} |
| try { |
| commandEncoder152.copyTextureToTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder153.pushDebugGroup('\u{1fbaf}'); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture151, |
| mipLevel: 0, |
| origin: {x: 79, y: 0, z: 16}, |
| aspect: 'all', |
| }, new Uint8Array(344).fill(98), /* required buffer size: 344 */ |
| {offset: 344}, {width: 113, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let texture168 = device0.createTexture({ |
| size: [419, 1, 26], |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder164 = commandEncoder151.beginComputePass({}); |
| let renderPassEncoder4 = commandEncoder149.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView139, |
| clearValue: { r: 469.6, g: 218.0, b: 629.1, a: -867.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup54, [768]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder68); computePassEncoder68.dispatchWorkgroupsIndirect(buffer42, 4_696); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer20, 12); |
| } catch {} |
| try { |
| commandEncoder143.copyBufferToTexture({ |
| /* bytesInLastRow: 38 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3602 */ |
| offset: 3602, |
| bytesPerRow: 4864, |
| rowsPerImage: 162, |
| buffer: buffer73, |
| }, { |
| texture: texture46, |
| mipLevel: 1, |
| origin: {x: 0, y: 7, z: 1}, |
| aspect: 'all', |
| }, {width: 19, height: 21, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder153 = device0.createCommandEncoder({}); |
| let computePassEncoder165 = commandEncoder143.beginComputePass({}); |
| let renderPassEncoder5 = commandEncoder153.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView124, |
| clearValue: { r: 636.6, g: 963.9, b: -960.4, a: -95.14, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet7, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder21.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer49, 2_148, 1_029); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2304 */ |
| offset: 2304, |
| bytesPerRow: 3840, |
| buffer: buffer41, |
| }, { |
| texture: texture47, |
| mipLevel: 2, |
| origin: {x: 58, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter1.label = '\u7967\u0c3b\u6efc\u6403\u36ea\ud679\u{1f893}\u89b7\u6c6a\ub811'; |
| } catch {} |
| let computePassEncoder166 = commandEncoder16.beginComputePass({}); |
| let sampler95 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest'}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| computePassEncoder125.setBindGroup(0, bindGroup8, new Uint32Array(353), 76, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder123); computePassEncoder123.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder156.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img0); |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'smpte170m', transfer: 'logSqrt'} }); |
| let bindGroup76 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 21, resource: textureView134}, |
| {binding: 106, resource: {buffer: buffer86, offset: 256, size: 1860}}, |
| {binding: 162, resource: {buffer: buffer86, offset: 512, size: 604}}, |
| {binding: 454, resource: {buffer: buffer83, offset: 256, size: 470}}, |
| ], |
| }); |
| let computePassEncoder167 = commandEncoder152.beginComputePass({}); |
| let sampler96 = device1.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', mipmapFilter: 'nearest', lodMinClamp: 11.87}); |
| try { |
| computePassEncoder159.setBindGroup(2, bindGroup75, [0]); |
| } catch {} |
| try { |
| computePassEncoder159.setBindGroup(0, bindGroup76, new Uint32Array(3033), 894, 1); |
| } catch {} |
| try { |
| buffer87.unmap(); |
| } catch {} |
| let texture169 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder115.setBindGroup(0, bindGroup29, [1280]); |
| } catch {} |
| try { |
| computePassEncoder110.setBindGroup(0, bindGroup73, new Uint32Array(338), 27, 1); |
| } catch {} |
| try { |
| computePassEncoder161.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup68, new Uint32Array(2371), 21, 1); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer11, 'uint32', 2_608, 93); |
| } catch {} |
| try { |
| buffer44.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| await gc(); |
| try { |
| device1.queue.label = '\u374b\u9591\uad62\u07b2\u0e44'; |
| } catch {} |
| let buffer91 = device1.createBuffer({ |
| size: 11027, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder154 = device1.createCommandEncoder({}); |
| let sampler97 = device1.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 96.08}); |
| let texture170 = gpuCanvasContext2.getCurrentTexture(); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(241).fill(51), /* required buffer size: 241 */ |
| {offset: 241, rowsPerImage: 41}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext3 = canvas1.getContext('webgpu'); |
| let buffer92 = device1.createBuffer({ |
| label: '\u5c9f\u{1fb0c}\u{1fddf}\u77de\u012b\u973a\u1f72', |
| size: 4640, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder155 = device1.createCommandEncoder({}); |
| let texture171 = device1.createTexture({ |
| size: [1, 80, 4], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView156 = texture144.createView({baseArrayLayer: 0}); |
| let computePassEncoder168 = commandEncoder154.beginComputePass({}); |
| try { |
| computePassEncoder137.setBindGroup(2, bindGroup75, new Uint32Array(4063), 1_287, 1); |
| } catch {} |
| try { |
| commandEncoder155.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 3568 */ |
| offset: 3568, |
| bytesPerRow: 25344, |
| rowsPerImage: 607, |
| buffer: buffer91, |
| }, { |
| texture: texture171, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 33, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture171, |
| mipLevel: 1, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(26).fill(137), /* required buffer size: 26 */ |
| {offset: 26, bytesPerRow: 12}, {width: 0, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| await gc(); |
| let commandEncoder156 = device1.createCommandEncoder({}); |
| let texture172 = device1.createTexture({ |
| size: [66], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView157 = texture144.createView({dimension: '2d-array', format: 'r32sint', baseMipLevel: 0}); |
| let bindGroup77 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer34, offset: 2048, size: 444}}], |
| }); |
| let textureView158 = texture82.createView({}); |
| try { |
| computePassEncoder76.setBindGroup(2, bindGroup8, new Uint32Array(3375), 44, 0); |
| } catch {} |
| try { |
| computePassEncoder157.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder4.setStencilReference(559); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer17); |
| } catch {} |
| let pipeline25 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment2', |
| constants: {}, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'add', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: {module: shaderModule6, buffers: []}, |
| primitive: {topology: 'point-list', frontFace: 'cw'}, |
| }); |
| document.body.prepend(img0); |
| let buffer93 = device1.createBuffer({ |
| label: '\uda27\u0104\u07e4\u3930\u{1f66f}\u96dd\u0d2f\u{1fd89}\u636d\ua1a9', |
| size: 5955, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let querySet25 = device1.createQuerySet({type: 'occlusion', count: 325}); |
| let computePassEncoder169 = commandEncoder156.beginComputePass({}); |
| try { |
| computePassEncoder158.setBindGroup(1, bindGroup76, [2304]); |
| } catch {} |
| try { |
| commandEncoder155.copyBufferToTexture({ |
| /* bytesInLastRow: 752 widthInBlocks: 94 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 568 */ |
| offset: 568, |
| buffer: buffer92, |
| }, { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 74, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 94, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture151, |
| mipLevel: 1, |
| origin: {x: 33, y: 0, z: 7}, |
| aspect: 'all', |
| }, new Uint8Array(214_263).fill(251), /* required buffer size: 214_263 */ |
| {offset: 119, bytesPerRow: 956, rowsPerImage: 14}, {width: 238, height: 0, depthOrArrayLayers: 17}); |
| } catch {} |
| let texture173 = device0.createTexture({ |
| size: [3357, 1, 1], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder62.end(); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup19, new Uint32Array(1018), 59, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.setScissorRect(0, 466, 0, 84); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer3, 'uint16', 374, 602); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline23); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToTexture({ |
| texture: texture96, |
| mipLevel: 4, |
| origin: {x: 0, y: 30, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture114, |
| mipLevel: 0, |
| origin: {x: 0, y: 27, z: 46}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let buffer94 = device1.createBuffer({ |
| size: 985, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler98 = device1.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| computePassEncoder152.setBindGroup(1, bindGroup72, [512]); |
| } catch {} |
| try { |
| buffer91.unmap(); |
| } catch {} |
| let querySet26 = device1.createQuerySet({type: 'occlusion', count: 714}); |
| let texture174 = device1.createTexture({ |
| size: {width: 226, height: 1, depthOrArrayLayers: 15}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder170 = commandEncoder155.beginComputePass({}); |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let computePassEncoder171 = commandEncoder61.beginComputePass(); |
| try { |
| computePassEncoder164.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer73, 'uint32', 7_960, 31_044); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline18); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture139, |
| mipLevel: 0, |
| origin: {x: 0, y: 15, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(22).fill(38), /* required buffer size: 22 */ |
| {offset: 22, bytesPerRow: 14}, {width: 0, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer95 = device1.createBuffer({ |
| size: 21132, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder169.setBindGroup(0, bindGroup75, new Uint32Array(375), 108, 1); |
| } catch {} |
| let commandEncoder157 = device0.createCommandEncoder(); |
| let textureView159 = texture94.createView({mipLevelCount: 1}); |
| let computePassEncoder172 = commandEncoder157.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder96); computePassEncoder96.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup13, new Uint32Array(505), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -297.7, g: -737.8, b: -272.1, a: -881.9, }); |
| } catch {} |
| try { |
| buffer64.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 21} |
| */ |
| { |
| source: videoFrame11, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 27, y: 12, z: 11}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture175 = device1.createTexture({size: [1, 80, 1], dimension: '2d', format: 'rgba32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let sampler99 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat'}); |
| try { |
| device0.queue.label = '\u01e9\u9d81\u063f\u0045'; |
| } catch {} |
| let commandEncoder158 = device0.createCommandEncoder(); |
| let textureView160 = texture39.createView({mipLevelCount: 1, arrayLayerCount: 5}); |
| let computePassEncoder173 = commandEncoder158.beginComputePass({}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm'], depthReadOnly: true}); |
| let renderBundle15 = renderBundleEncoder15.finish({label: '\u{1fcfa}\uce61'}); |
| try { |
| computePassEncoder113.setBindGroup(2, bindGroup65, new Uint32Array(1145), 248, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(5, buffer73, 3_144, 11_372); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 196, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 13, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture96, |
| mipLevel: 3, |
| origin: {x: 0, y: 23, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture176 = device1.createTexture({ |
| size: {width: 528}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView161 = texture172.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder153.popDebugGroup(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let bindGroup78 = device1.createBindGroup({ |
| label: '\u94da\ud17f\u0331\u0bdf\ucdbb\u0f78\u93a8', |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer92, offset: 0, size: 956}}, |
| {binding: 21, resource: textureView154}, |
| {binding: 454, resource: {buffer: buffer93, offset: 512, size: 922}}, |
| {binding: 106, resource: {buffer: buffer92, offset: 0}}, |
| ], |
| }); |
| let texture177 = device1.createTexture({ |
| size: {width: 264, height: 20, depthOrArrayLayers: 7}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView162 = texture171.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder158.setBindGroup(2, bindGroup76, [512]); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(193).fill(233), /* required buffer size: 193 */ |
| {offset: 193, rowsPerImage: 61}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise24 = device1.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext4 = offscreenCanvas5.getContext('webgpu'); |
| try { |
| await promise24; |
| } catch {} |
| let texture178 = device0.createTexture({ |
| size: [1, 547, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder109); computePassEncoder109.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder47.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup71, [0]); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup25, new Uint32Array(1405), 47, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let texture179 = device0.createTexture({ |
| size: {width: 3357}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView163 = texture0.createView({}); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup73, [7168]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder106); computePassEncoder106.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder172.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup37, new Uint32Array(1335), 130, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer67, 388, new DataView(new ArrayBuffer(43316)), 4015, 108); |
| } catch {} |
| let texture180 = device0.createTexture({ |
| size: {width: 1, height: 393, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler100 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder96.setBindGroup(0, bindGroup10, [768]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder100); computePassEncoder100.dispatchWorkgroupsIndirect(buffer84, 12_924); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer20, 'uint16', 6, 40); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline25); |
| } catch {} |
| let externalTexture10 = device1.importExternalTexture({source: videoFrame14, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder162.setBindGroup(1, bindGroup76, [256]); |
| } catch {} |
| try { |
| computePassEncoder151.setBindGroup(2, bindGroup72, new Uint32Array(2217), 182, 1); |
| } catch {} |
| try { |
| device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let bindGroup79 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer95, offset: 1536, size: 668}}, |
| {binding: 454, resource: {buffer: buffer77, offset: 512, size: 3898}}, |
| {binding: 21, resource: textureView154}, |
| {binding: 106, resource: {buffer: buffer86, offset: 0, size: 2552}}, |
| ], |
| }); |
| let buffer96 = device1.createBuffer({size: 1878, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder159 = device1.createCommandEncoder({label: '\u8120\u05eb\u3a78\u7e5b\u{1f838}\u727f\ucdc6\u{1f85d}'}); |
| let sampler101 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 71.44, |
| lodMaxClamp: 93.52, |
| }); |
| try { |
| computePassEncoder152.setBindGroup(3, bindGroup79, [0]); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 324, y: 34, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(231).fill(213), /* required buffer size: 231 */ |
| {offset: 231}, {width: 543, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let buffer97 = device0.createBuffer({ |
| size: 6711, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup61, [512]); |
| } catch {} |
| try { |
| computePassEncoder163.setPipeline(pipeline2); |
| } catch {} |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder173.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle15, renderBundle9, renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer8, 300, new DataView(new ArrayBuffer(4648)), 825, 252); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup80 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 106, resource: {buffer: buffer95, offset: 0}}, |
| {binding: 454, resource: {buffer: buffer86, offset: 1536, size: 105}}, |
| {binding: 21, resource: textureView141}, |
| {binding: 162, resource: {buffer: buffer92, offset: 512}}, |
| ], |
| }); |
| let commandEncoder161 = device1.createCommandEncoder({}); |
| let texture181 = device1.createTexture({ |
| size: {width: 1810, height: 1, depthOrArrayLayers: 85}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder174 = commandEncoder159.beginComputePass({}); |
| let sampler102 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder159.setBindGroup(2, bindGroup79, new Uint32Array(2080), 298, 1); |
| } catch {} |
| try { |
| commandEncoder161.copyBufferToTexture({ |
| /* bytesInLastRow: 1904 widthInBlocks: 476 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 48 */ |
| offset: 48, |
| bytesPerRow: 13312, |
| rowsPerImage: 672, |
| buffer: buffer92, |
| }, { |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 72, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 476, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 59, resource: textureView20}]}); |
| let commandEncoder162 = device0.createCommandEncoder({}); |
| let texture182 = device0.createTexture({ |
| size: [256], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder175 = commandEncoder160.beginComputePass({}); |
| let sampler103 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.26, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder165.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup20, new Uint32Array(2568), 50, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle9, renderBundle15, renderBundle15, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer97); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder162.copyBufferToBuffer(buffer19, 116, buffer17, 716, 3804); |
| } catch {} |
| try { |
| commandEncoder162.copyTextureToBuffer({ |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 192, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 656 */ |
| offset: 656, |
| rowsPerImage: 41, |
| buffer: buffer33, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder162.clearBuffer(buffer67); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| try { |
| computePassEncoder158.setBindGroup(3, bindGroup72, [0]); |
| } catch {} |
| try { |
| commandEncoder161.copyTextureToTexture({ |
| texture: texture177, |
| mipLevel: 0, |
| origin: {x: 11, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 258, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer94, 60, new BigUint64Array(11041), 7, 8); |
| } catch {} |
| let buffer98 = device0.createBuffer({size: 8619, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame12}); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup20, new Uint32Array(2114), 83, 1); |
| } catch {} |
| let bindGroup82 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer92, offset: 1280}}, |
| {binding: 106, resource: {buffer: buffer92, offset: 0}}, |
| {binding: 21, resource: textureView156}, |
| {binding: 454, resource: {buffer: buffer76, offset: 0}}, |
| ], |
| }); |
| let buffer99 = device1.createBuffer({ |
| size: 14485, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder163 = device1.createCommandEncoder({}); |
| let texture183 = device1.createTexture({ |
| size: [66], |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView164 = texture181.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 54}); |
| try { |
| commandEncoder163.clearBuffer(buffer83, 20, 32); |
| } catch {} |
| let promise25 = device1.queue.onSubmittedWorkDone(); |
| let commandEncoder164 = device1.createCommandEncoder({}); |
| let texture184 = device1.createTexture({ |
| size: {width: 280, height: 5, depthOrArrayLayers: 24}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder176 = commandEncoder161.beginComputePass({}); |
| try { |
| computePassEncoder149.setBindGroup(0, bindGroup76, [0]); |
| } catch {} |
| try { |
| computePassEncoder142.setBindGroup(0, bindGroup76, new Uint32Array(5062), 580, 1); |
| } catch {} |
| try { |
| commandEncoder164.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 616 */ |
| offset: 616, |
| buffer: buffer95, |
| }, { |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let texture185 = device1.createTexture({ |
| size: {width: 4, height: 320, depthOrArrayLayers: 60}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder177 = commandEncoder164.beginComputePass(); |
| try { |
| computePassEncoder169.setBindGroup(2, bindGroup79, new Uint32Array(1273), 68, 1); |
| } catch {} |
| let buffer100 = device1.createBuffer({size: 15595, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder165 = device1.createCommandEncoder({}); |
| let textureView165 = texture185.createView({mipLevelCount: 1}); |
| let texture186 = device1.createTexture({ |
| size: {width: 2, height: 160, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView166 = texture183.createView({label: '\ue30b\u{1f6d3}\u076c', baseArrayLayer: 0}); |
| let computePassEncoder178 = commandEncoder163.beginComputePass({}); |
| try { |
| computePassEncoder152.setBindGroup(3, bindGroup72, [1024]); |
| } catch {} |
| try { |
| commandEncoder165.copyBufferToTexture({ |
| /* bytesInLastRow: 1188 widthInBlocks: 297 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 100 */ |
| offset: 100, |
| bytesPerRow: 21760, |
| buffer: buffer87, |
| }, { |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 172, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 297, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder165.resolveQuerySet(querySet26, 164, 129, buffer91, 256); |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 42, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 55, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 70, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView167 = texture159.createView({}); |
| let texture187 = device1.createTexture({ |
| size: [66, 5, 4], |
| dimension: '2d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler104 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.29, |
| }); |
| offscreenCanvas3.height = 30; |
| let texture188 = device0.createTexture({size: [1], dimension: '1d', format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup27, new Uint32Array(950), 444, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder66); computePassEncoder66.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder71); computePassEncoder71.dispatchWorkgroupsIndirect(buffer47, 1_016); }; |
| } catch {} |
| try { |
| computePassEncoder175.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup48, new Uint32Array(5116), 2_166, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.beginOcclusionQuery(14); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline9); |
| } catch {} |
| try { |
| texture5.destroy(); |
| } catch {} |
| try { |
| commandEncoder162.clearBuffer(buffer1, 1236, 2492); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer101 = device0.createBuffer({ |
| size: 13993, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let textureView168 = texture118.createView({aspect: 'stencil-only', format: 'stencil8', baseMipLevel: 3, mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder179 = commandEncoder162.beginComputePass({}); |
| try { |
| computePassEncoder112.setBindGroup(0, bindGroup54, new Uint32Array(902), 125, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder117); computePassEncoder117.dispatchWorkgroupsIndirect(buffer11, 68); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup14, [768]); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup23, new Uint32Array(976), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer44, 4_552); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas1); |
| let canvas3 = document.createElement('canvas'); |
| let computePassEncoder180 = commandEncoder166.beginComputePass({}); |
| try { |
| device0.queue.writeBuffer(buffer27, 340, new DataView(new ArrayBuffer(7139)), 361, 228); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 7}, |
| aspect: 'all', |
| }, new Uint8Array(66_427).fill(125), /* required buffer size: 66_427 */ |
| {offset: 126, bytesPerRow: 259}, {width: 256, height: 256, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.append(img0); |
| let recycledExplicitBindGroupLayout14 = pipeline3.getBindGroupLayout(0); |
| let sampler105 = device0.createSampler({minFilter: 'linear', lodMinClamp: 5.607}); |
| try { |
| computePassEncoder44.setBindGroup(0, bindGroup4, new Uint32Array(420), 16, 1); |
| } catch {} |
| try { |
| computePassEncoder171.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 7420, new BigUint64Array(3445), 123, 84); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(286).fill(168), /* required buffer size: 286 */ |
| {offset: 286, bytesPerRow: 24, rowsPerImage: 9}, {width: 0, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup83 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 454, resource: {buffer: buffer99, offset: 1536, size: 5551}}, |
| {binding: 162, resource: {buffer: buffer92, offset: 1792}}, |
| {binding: 106, resource: {buffer: buffer86, offset: 512, size: 2380}}, |
| {binding: 21, resource: textureView156}, |
| ], |
| }); |
| let buffer102 = device1.createBuffer({size: 1224, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder159.setBindGroup(3, bindGroup78, [0]); |
| } catch {} |
| try { |
| commandEncoder165.copyTextureToBuffer({ |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 3}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2640 */ |
| offset: 2640, |
| buffer: buffer82, |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture189 = device0.createTexture({ |
| size: {width: 1678, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView169 = texture48.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder101.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| computePassEncoder179.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup33, [0]); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline25); |
| } catch {} |
| let imageData17 = new ImageData(12, 80); |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| @size(44) f0: array<u32>, |
| } |
| |
| var<workgroup> vw18: atomic<u32>; |
| |
| var<workgroup> vw19: array<array<array<bool, 1>, 1>, 13>; |
| |
| var<workgroup> vw26: array<array<array<f16, 1>, 17>, 1>; |
| |
| var<workgroup> vw15: atomic<u32>; |
| |
| var<workgroup> vw25: FragmentOutput4; |
| |
| var<workgroup> vw22: atomic<i32>; |
| |
| var<workgroup> vw20: FragmentOutput4; |
| |
| struct T1 { |
| @size(44) f0: array<u32>, |
| } |
| |
| @group(0) @binding(174) var<storage, read> buffer103: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 2>, 1>, 11>, 1>, 1>, 1>>; |
| |
| var<workgroup> vw14: vec2<bool>; |
| |
| var<workgroup> vw16: FragmentOutput4; |
| |
| var<workgroup> vw24: array<array<FragmentOutput4, 5>, 1>; |
| |
| var<workgroup> vw23: mat2x4h; |
| |
| struct FragmentOutput4 { |
| @location(4) f0: vec2i, |
| @location(0) f1: vec2f, |
| } |
| |
| var<workgroup> vw21: array<array<atomic<u32>, 1>, 3>; |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T2 { |
| @size(8) f0: array<u32>, |
| } |
| |
| var<private> vp12 = modf(vec4f(0.04557, 0.03826, 0.2556, 0.3773)); |
| |
| var<workgroup> vw17: atomic<i32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T3 { |
| @size(44) f0: T2, |
| } |
| |
| /* used global variables: buffer103 */ |
| @fragment |
| fn fragment7(@builtin(front_facing) a0: bool) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| let ptr54: ptr<storage, f16, read> = &buffer103[arrayLength(&buffer103)][0][0][0][10][unconst_u32(113)][1][unconst_u32(23)][0]; |
| out.f0 -= vec2i(i32((*&buffer103)[arrayLength(&(*&buffer103))][unconst_u32(310)][0][0][unconst_u32(395)][unconst_u32(164)][unconst_u32(83)][0][0])); |
| let ptr55: ptr<storage, array<f16, 1>, read> = &(*&buffer103)[unconst_u32(410)][0][0][0][unconst_u32(413)][0][1][0]; |
| let ptr56: ptr<storage, array<f16, 1>, read> = &buffer103[arrayLength(&buffer103)][unconst_u32(9)][0][0][10][0][1][unconst_u32(9)]; |
| switch i32(buffer103[arrayLength(&buffer103)][0][unconst_u32(62)][0][10][unconst_u32(36)][unconst_u32(229)][unconst_u32(18)][0]) { |
| default { |
| out = FragmentOutput4(vec2i(i32(buffer103[unconst_u32(225)][0][unconst_u32(169)][0][unconst_u32(849)][0][1][0][0])), vec2f(f32(buffer103[unconst_u32(225)][0][unconst_u32(169)][0][unconst_u32(849)][0][1][0][0]))); |
| let ptr57: ptr<storage, f16, read> = &buffer103[unconst_u32(617)][0][0][0][unconst_u32(468)][unconst_u32(169)][u32((*&buffer103)[u32(buffer103[unconst_u32(59)][0][0][unconst_u32(117)][10][0][1][0][0])][unconst_u32(243)][unconst_u32(65)][unconst_u32(3)][10][0][1][0][0])][unconst_u32(39)][unconst_u32(33)]; |
| break; |
| _ = buffer103; |
| } |
| } |
| return out; |
| _ = buffer103; |
| }`, |
| }); |
| let recycledExplicitBindGroupLayout15 = pipeline9.getBindGroupLayout(0); |
| let bindGroup84 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [{binding: 174, resource: {buffer: buffer74, offset: 512, size: 296}}], |
| }); |
| let texture190 = device0.createTexture({ |
| size: {width: 1, height: 196, depthOrArrayLayers: 39}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder108.setBindGroup(0, bindGroup40, [0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder117.end(); |
| } catch {} |
| try { |
| computePassEncoder166.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer89, 'uint16', 3_432, 9_156); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline16); |
| } catch {} |
| try { |
| commandEncoder105.copyTextureToTexture({ |
| texture: texture188, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture129, |
| mipLevel: 1, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder105.clearBuffer(buffer8, 16, 884); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup85 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout9, |
| entries: [{binding: 174, resource: {buffer: buffer31, offset: 0, size: 44}}], |
| }); |
| let commandEncoder167 = device0.createCommandEncoder(); |
| let sampler106 = device0.createSampler({ |
| label: '\u6990\u1a6b\u{1fbea}\u0683\uf585\u97c2', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder104); computePassEncoder104.dispatchWorkgroupsIndirect(buffer5, 16); }; |
| } catch {} |
| try { |
| computePassEncoder180.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup18, new Uint32Array(1362), 168, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -865.4, g: 555.0, b: -265.5, a: 657.3, }); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer25, 1_932, 365); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 40, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(277).fill(221), /* required buffer size: 277 */ |
| {offset: 277}, {width: 59, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 432, resource: textureView59}, {binding: 77, resource: textureView63}], |
| }); |
| let computePassEncoder181 = commandEncoder105.beginComputePass({}); |
| let renderPassEncoder6 = commandEncoder167.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView139, |
| clearValue: { r: -914.7, g: -517.9, b: -752.4, a: -113.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet19, |
| }); |
| let sampler107 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 97.55}); |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup63); |
| } catch {} |
| try { |
| computePassEncoder181.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup20, new Uint32Array(4077), 932, 1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 419, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture146, |
| mipLevel: 2, |
| origin: {x: 53, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture191 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder172.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer26, 'uint32', 68, 1_659); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer31, 684); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer67, 280, new Float32Array(11401), 941, 128); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline26 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule3, constants: {}}}); |
| let veryExplicitBindGroupLayout22 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 177, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 251, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup87 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [ |
| {binding: 177, resource: {buffer: buffer86, offset: 1280, size: 1084}}, |
| {binding: 251, resource: {buffer: buffer95, offset: 1792}}, |
| ], |
| }); |
| let texture192 = device1.createTexture({ |
| size: [528, 40, 4], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder159.setBindGroup(3, bindGroup75, [1024]); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer77, 5936, new DataView(new ArrayBuffer(5472)), 330, 2124); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer104 = device0.createBuffer({ |
| size: 7160, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder168 = device0.createCommandEncoder(); |
| let renderPassEncoder7 = commandEncoder168.beginRenderPass({ |
| label: '\uce8b\u0204\u07f3\u{1fcea}\u{1fbe9}\u8261\u7ea9\u{1fee4}\uce84', |
| colorAttachments: [{ |
| view: textureView139, |
| clearValue: { r: 880.1, g: 512.1, b: -253.9, a: -610.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet5, |
| }); |
| let sampler108 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 82.51, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder53.setBindGroup(1, bindGroup49); |
| } catch {} |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup84, new Uint32Array(1618), 236, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer22, 'uint32', 1_092, 377); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 787, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 3, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture119, |
| mipLevel: 1, |
| origin: {x: 0, y: 308, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder169 = device1.createCommandEncoder({}); |
| let textureView170 = texture162.createView({mipLevelCount: 1}); |
| let texture193 = device1.createTexture({ |
| size: {width: 905, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder153.setBindGroup(0, bindGroup75, new Uint32Array(1221), 259, 1); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(60).fill(71), /* required buffer size: 60 */ |
| {offset: 60}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder170 = device1.createCommandEncoder({}); |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 87, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let commandEncoder171 = device0.createCommandEncoder(); |
| let texture194 = device0.createTexture({ |
| size: {width: 1, height: 547, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| sampleCount: 4, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['stencil8'], |
| }); |
| let computePassEncoder182 = commandEncoder171.beginComputePass({}); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer19, 'uint32', 524, 57); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(4, buffer52); |
| } catch {} |
| let gpuCanvasContext5 = canvas3.getContext('webgpu'); |
| await gc(); |
| try { |
| globalThis.someLabel = sampler92.label; |
| } catch {} |
| let texture195 = device1.createTexture({size: [2], mipLevelCount: 1, dimension: '1d', format: 'rgba32uint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder183 = commandEncoder165.beginComputePass({}); |
| let commandEncoder172 = device1.createCommandEncoder({}); |
| let computePassEncoder184 = commandEncoder170.beginComputePass(); |
| let sampler109 = device1.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let texture196 = device1.createTexture({ |
| size: {width: 1, height: 80, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView171 = texture151.createView({format: 'rgba8snorm', baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| let bindGroup88 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 106, resource: {buffer: buffer95, offset: 2048}}, |
| {binding: 454, resource: {buffer: buffer77, offset: 256, size: 2902}}, |
| {binding: 21, resource: textureView154}, |
| {binding: 162, resource: {buffer: buffer92, offset: 256}}, |
| ], |
| }); |
| let commandEncoder173 = device1.createCommandEncoder({}); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture196, |
| mipLevel: 0, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(387).fill(0), /* required buffer size: 387 */ |
| {offset: 387, bytesPerRow: 45}, {width: 0, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler110 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 99.64}); |
| try { |
| computePassEncoder181.setBindGroup(1, bindGroup6, new Uint32Array(2578), 146, 0); |
| } catch {} |
| try { |
| computePassEncoder182.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline16); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 0, y: 25, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer105 = device0.createBuffer({size: 4575, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let texture197 = device0.createTexture({ |
| size: {width: 839, height: 1, depthOrArrayLayers: 125}, |
| mipLevelCount: 3, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView172 = texture52.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rg16uint'], depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup69); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup29, new Uint32Array(1410), 457, 1); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| canvas0.height = 432; |
| let recycledExplicitBindGroupLayout16 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder174 = device0.createCommandEncoder(); |
| let renderPassEncoder8 = commandEncoder7.beginRenderPass({colorAttachments: [{view: textureView150, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup6, new Uint32Array(436), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer7, 0, 1_026); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| let texture198 = device0.createTexture({ |
| size: [2, 1095, 1], |
| sampleCount: 4, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView173 = texture140.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder136.setBindGroup(3, bindGroup1, new Uint32Array(2394), 5, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder123); computePassEncoder123.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer84, 312); }; |
| } catch {} |
| try { |
| computePassEncoder41.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup44, new Uint32Array(1333), 74, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(2, 271, 662_215_689, 58_054_634); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(2, 285, 2, -1_650_851_557, 490_786_899); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer47, 1_084); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer73, 'uint32', 9_184, 3_293); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer71, 108); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer63, 'uint32', 2_832, 480); |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [{binding: 174, resource: {buffer: buffer80, offset: 3584, size: 72}}], |
| }); |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| computePassEncoder141.setBindGroup(2, bindGroup12, new Uint32Array(716), 76, 0); |
| } catch {} |
| try { |
| computePassEncoder31.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup11, new Uint32Array(1148), 147, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(26); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(93, 254, 1_762_166_040, 2_833_891_814); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer69, 1_816); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer41, 'uint16', 1_626, 1_035); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(1, buffer69, 56, 637); |
| } catch {} |
| try { |
| renderBundleEncoder16.insertDebugMarker('\u{1fd64}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 716, new Float32Array(16813), 1882, 28); |
| } catch {} |
| let promise26 = device0.createRenderPipelineAsync({ |
| layout: pipelineLayout7, |
| fragment: {module: shaderModule5, constants: {override8: 1}, targets: [{format: 'rg8unorm'}]}, |
| vertex: {module: shaderModule4, entryPoint: 'vertex4', buffers: []}, |
| }); |
| document.body.append(img0); |
| let buffer106 = device0.createBuffer({ |
| size: 810, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder185 = commandEncoder174.beginComputePass({}); |
| try { |
| computePassEncoder55.setBindGroup(0, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer21, 4_228); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer54, 2_400); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer11, 0, 2_397); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(5, buffer52, 0, 25); |
| } catch {} |
| try { |
| querySet4.destroy(); |
| } catch {} |
| let promise27 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext6 = canvas2.getContext('webgpu'); |
| try { |
| await promise27; |
| } catch {} |
| let buffer107 = device0.createBuffer({size: 1433, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let textureView174 = texture132.createView({format: 'rg16uint'}); |
| let renderPassEncoder9 = commandEncoder14.beginRenderPass({colorAttachments: [{view: textureView139, loadOp: 'clear', storeOp: 'discard'}]}); |
| let sampler111 = device0.createSampler({addressModeV: 'mirror-repeat', lodMinClamp: 69.98, lodMaxClamp: 72.87, compare: 'greater'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder123); computePassEncoder123.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder74.end(); |
| } catch {} |
| try { |
| computePassEncoder66.setPipeline(pipeline8); |
| } catch {} |
| try { |
| computePassEncoder185.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(3, 76, 0, 11_950_677, 711_577_710); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer71, 12); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer69, 1_152); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer72, 'uint16', 6_248, 4_956); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup34, new Uint32Array(202), 100, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer97, 552); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer89, 'uint32', 2_116, 4_771); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToBuffer(buffer67, 76, buffer10, 140, 28); |
| } catch {} |
| let promise28 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1095, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 0, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 0, y: 271, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView175 = texture144.createView({format: 'r32sint'}); |
| try { |
| commandEncoder172.copyTextureToBuffer({ |
| texture: texture160, |
| mipLevel: 0, |
| origin: {x: 19, y: 8, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 232 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 136 */ |
| offset: 136, |
| bytesPerRow: 34304, |
| buffer: buffer91, |
| }, {width: 29, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({layout: veryExplicitBindGroupLayout15, entries: [{binding: 360, resource: textureView105}]}); |
| let buffer108 = device0.createBuffer({ |
| size: 18432, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| let textureView176 = texture119.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder186 = commandEncoder29.beginComputePass({}); |
| let renderPassEncoder10 = commandEncoder176.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView130, |
| clearValue: { r: 516.2, g: -617.7, b: 932.8, a: 341.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 63771878, |
| }); |
| try { |
| computePassEncoder103.setBindGroup(0, bindGroup52, new Uint32Array(1032), 30, 1); |
| } catch {} |
| try { |
| computePassEncoder186.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(0, 186, 2, 1_516_131_855, 1_691_726_415); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer97, 3_252); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer42, 'uint32', 352, 2_401); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer16, 772); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup51, new Uint32Array(4820), 578, 1); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer104, 224); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder175.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 476 */ |
| offset: 412, |
| buffer: buffer11, |
| }, { |
| texture: texture58, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 8}, |
| aspect: 'stencil-only', |
| }, {width: 64, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder31.resolveQuerySet(querySet15, 121, 20, buffer65, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 79, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(95).fill(115), /* required buffer size: 95 */ |
| {offset: 95}, {width: 68, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let imageData18 = new ImageData(60, 12); |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte170m', transfer: 'linear'} }); |
| let texture199 = device0.createTexture({size: [3357, 1, 59], format: 'rg8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, viewFormats: []}); |
| let textureView177 = texture80.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderPassEncoder11 = commandEncoder175.beginRenderPass({colorAttachments: [{view: textureView176, loadOp: 'load', storeOp: 'store'}], maxDrawCount: 68359566}); |
| let sampler112 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.98, |
| }); |
| try { |
| computePassEncoder76.setBindGroup(1, bindGroup63, new Uint32Array(251), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup58, new Uint32Array(2908), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(286, 314, 418_341_167, 738_454_911); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer34, 816); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(6, buffer19, 232, 127); |
| } catch {} |
| try { |
| renderBundleEncoder16.draw(284, 48, 554_400_512, 1_207_510_891); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(290, 136, 25, 792_868_267, 397_604_901); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer84, 3_184); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer73, 'uint32', 6_968, 11_384); |
| } catch {} |
| try { |
| commandEncoder31.insertDebugMarker('\u{1f8bd}'); |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [{binding: 174, resource: {buffer: buffer106, offset: 0, size: 224}}], |
| }); |
| let texture200 = device0.createTexture({ |
| size: [1678, 1, 1], |
| mipLevelCount: 3, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView178 = texture70.createView({aspect: 'all', baseMipLevel: 0, baseArrayLayer: 0}); |
| let sampler113 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder68.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle9, renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(0.07127025404227583, 587.2737173010242, 2.684269016344676, 833.216048278188, 0.40771849822582196, 0.6215727445416475); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer42, 1_656); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer19, 'uint16', 570, 545); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder16.draw(228, 138, 102_954_116, 443_156_888); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(310, 12, 285, 568_148_945, 275_322_652); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer60, 4_604); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); }; |
| } catch {} |
| let textureView179 = texture151.createView({mipLevelCount: 1}); |
| try { |
| commandEncoder173.copyTextureToBuffer({ |
| texture: texture160, |
| mipLevel: 0, |
| origin: {x: 14, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 72 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 744 */ |
| offset: 744, |
| bytesPerRow: 512, |
| rowsPerImage: 819, |
| buffer: buffer91, |
| }, {width: 9, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder172.copyTextureToTexture({ |
| texture: texture162, |
| mipLevel: 1, |
| origin: {x: 297, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture172, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| let computePassEncoder187 = commandEncoder31.beginComputePass({}); |
| try { |
| computePassEncoder187.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(66, 793, 380_974_773, 720_769_723); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer34, 9_132); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(1, buffer48); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer47, 3_684); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 432 */ |
| offset: 432, |
| bytesPerRow: 3840, |
| buffer: buffer16, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 24, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder177.copyTextureToBuffer({ |
| texture: texture133, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 839 widthInBlocks: 839 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1864 */ |
| offset: 1864, |
| buffer: buffer19, |
| }, {width: 839, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder69.clearBuffer(buffer9, 5096, 5052); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer68, 108, new Float32Array(2559), 210, 600); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let renderPassEncoder12 = commandEncoder69.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView176, |
| clearValue: { r: 412.3, g: -693.8, b: 863.0, a: -854.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler114 = device0.createSampler({addressModeU: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 96.91}); |
| try { |
| renderPassEncoder4.draw(3, 208, 47_017_395, 1_144_850_799); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexed(35, 117, 1_395, 359_896_253, 1_039_762_093); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer55, 1_212); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexed(609, 63, 302, 30_560_776, 1_154_233_265); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer84, 3_848); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(3, buffer25, 124, 330); |
| } catch {} |
| try { |
| commandEncoder177.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 126 */ |
| offset: 126, |
| bytesPerRow: 13312, |
| buffer: buffer59, |
| }, { |
| texture: texture120, |
| mipLevel: 2, |
| origin: {x: 45, y: 0, z: 14}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder177.resolveQuerySet(querySet16, 694, 58, buffer28, 1792); |
| } catch {} |
| try { |
| renderPassEncoder11.insertDebugMarker('\u04ed'); |
| } catch {} |
| let commandEncoder178 = device1.createCommandEncoder(); |
| let computePassEncoder188 = commandEncoder169.beginComputePass({}); |
| let sampler115 = device1.createSampler({addressModeW: 'mirror-repeat', minFilter: 'nearest', mipmapFilter: 'linear', lodMaxClamp: 70.32}); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture172, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(69).fill(29), /* required buffer size: 69 */ |
| {offset: 69, rowsPerImage: 0}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let img1 = await imageWithData(5, 60, '#10101010', '#20202020'); |
| let commandEncoder179 = device1.createCommandEncoder({}); |
| let texture201 = device1.createTexture({ |
| size: [4, 320, 1], |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView180 = texture144.createView({dimension: '2d-array'}); |
| let renderBundleEncoder17 = device1.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup79, new Uint32Array(5036), 3_006, 1); |
| } catch {} |
| try { |
| commandEncoder172.copyBufferToBuffer(buffer95, 760, buffer77, 7792, 2924); |
| } catch {} |
| try { |
| commandEncoder178.copyTextureToTexture({ |
| texture: texture192, |
| mipLevel: 0, |
| origin: {x: 187, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder183.setBindGroup(3, bindGroup75, [256]); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup79, [0]); |
| } catch {} |
| try { |
| commandEncoder179.copyBufferToTexture({ |
| /* bytesInLastRow: 688 widthInBlocks: 172 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 464 */ |
| offset: 464, |
| bytesPerRow: 4352, |
| buffer: buffer87, |
| }, { |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 36, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 172, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder179.copyTextureToBuffer({ |
| texture: texture160, |
| mipLevel: 0, |
| origin: {x: 38, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 272 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 480 */ |
| offset: 480, |
| bytesPerRow: 1280, |
| buffer: buffer77, |
| }, {width: 34, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup92 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout16, |
| entries: [{binding: 174, resource: {buffer: buffer28, offset: 5376, size: 488}}], |
| }); |
| let buffer109 = device0.createBuffer({ |
| size: 37116, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandBuffer17 = commandEncoder177.finish({}); |
| let renderBundle16 = renderBundleEncoder16.finish({}); |
| try { |
| computePassEncoder42.setBindGroup(2, bindGroup37, new Uint32Array(3816), 78, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(89, 18, 2_743_104_549, 210_641_009); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(1, 84, 0, -2_134_991_633, 2_068_789_045); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer34); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer17]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 42, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(105_953).fill(179), /* required buffer size: 105_953 */ |
| {offset: 97, bytesPerRow: 112, rowsPerImage: 119}, {width: 4, height: 113, depthOrArrayLayers: 8}); |
| } catch {} |
| let promise29 = device0.queue.onSubmittedWorkDone(); |
| let pipeline27 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule0}}); |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); }; |
| } catch {} |
| let buffer110 = device0.createBuffer({ |
| size: 3752, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture202 = gpuCanvasContext4.getCurrentTexture(); |
| let textureView181 = texture82.createView({}); |
| try { |
| computePassEncoder164.setBindGroup(2, bindGroup90); |
| } catch {} |
| try { |
| computePassEncoder143.setBindGroup(2, bindGroup5, new Uint32Array(933), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(139, 499, 699_998_550, 1_025_263_537); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer66, 2_136); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 547, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 34, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture129, |
| mipLevel: 1, |
| origin: {x: 0, y: 27, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder180 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder149.setBindGroup(2, bindGroup78, new Uint32Array(341), 2, 1); |
| } catch {} |
| try { |
| commandEncoder178.resolveQuerySet(querySet21, 269, 9, buffer99, 256); |
| } catch {} |
| let sampler116 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat'}); |
| let commandEncoder181 = device1.createCommandEncoder({}); |
| let texture203 = device1.createTexture({ |
| size: {width: 1, height: 80, depthOrArrayLayers: 17}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder178.setBindGroup(3, bindGroup72, [256]); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup79, [1536]); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(5, buffer102); |
| } catch {} |
| let bindGroup93 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer92, offset: 0}}, |
| {binding: 106, resource: {buffer: buffer86, offset: 512, size: 2884}}, |
| {binding: 21, resource: textureView175}, |
| {binding: 454, resource: {buffer: buffer99, offset: 3072, size: 982}}, |
| ], |
| }); |
| let buffer111 = device1.createBuffer({size: 8931, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let computePassEncoder189 = commandEncoder179.beginComputePass({}); |
| let externalTexture13 = device1.importExternalTexture({source: videoFrame18}); |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer93, 'uint16', 1_430, 1_487); |
| } catch {} |
| let imageData19 = new ImageData(160, 100); |
| let bindGroup94 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 21, resource: textureView156}, |
| {binding: 162, resource: {buffer: buffer86, offset: 2048, size: 800}}, |
| {binding: 106, resource: {buffer: buffer86, offset: 1024, size: 1780}}, |
| {binding: 454, resource: {buffer: buffer99, offset: 2816, size: 1272}}, |
| ], |
| }); |
| let buffer112 = device1.createBuffer({size: 5017, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder182 = device1.createCommandEncoder({}); |
| let textureView182 = texture161.createView({}); |
| let sampler117 = device1.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'linear'}); |
| try { |
| computePassEncoder167.setBindGroup(0, bindGroup78, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(1, bindGroup79, new Uint32Array(733), 82, 1); |
| } catch {} |
| try { |
| buffer93.unmap(); |
| } catch {} |
| try { |
| commandEncoder178.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 544 */ |
| offset: 544, |
| bytesPerRow: 7168, |
| buffer: buffer111, |
| }, { |
| texture: texture196, |
| mipLevel: 0, |
| origin: {x: 0, y: 25, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 28, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer92, 184, new Int16Array(5883), 2238, 348); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup1, new Uint32Array(627), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer54, 3_208); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer72, 1_024); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 136, depthOrArrayLayers: 20} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 0, y: 6, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup95 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 174, resource: {buffer: buffer35, offset: 512, size: 1856}}], |
| }); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let computePassEncoder190 = commandEncoder183.beginComputePass({}); |
| try { |
| computePassEncoder190.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer25, 460); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline9); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 68, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(20).fill(99), /* required buffer size: 20 */ |
| {offset: 20, rowsPerImage: 102}, {width: 80, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); }; |
| } catch {} |
| let recycledExplicitBindGroupLayout17 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let computePassEncoder191 = commandEncoder184.beginComputePass({}); |
| let sampler118 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMaxClamp: 95.62}); |
| try { |
| computePassEncoder191.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup57, [0]); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup8, new Uint32Array(615), 48, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(35, 19, 72_296_060, 1_350_041_538); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| document.body.append(img1); |
| let texture204 = device1.createTexture({ |
| size: {width: 264}, |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView183 = texture151.createView({mipLevelCount: 1}); |
| let renderPassEncoder13 = commandEncoder181.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView182, |
| depthSlice: 1, |
| clearValue: { r: -311.4, g: -887.2, b: -173.3, a: 428.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet26, |
| }); |
| let renderBundle17 = renderBundleEncoder17.finish({}); |
| try { |
| renderPassEncoder13.setVertexBuffer(7, undefined, 1_473_687_847); |
| } catch {} |
| try { |
| computePassEncoder170.pushDebugGroup('\ua71e'); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture196, |
| mipLevel: 0, |
| origin: {x: 0, y: 22, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(192).fill(8), /* required buffer size: 192 */ |
| {offset: 192, bytesPerRow: 6}, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup96 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 116, resource: {buffer: buffer34, offset: 6656, size: 4260}}, |
| {binding: 70, resource: {buffer: buffer26, offset: 512, size: 1138}}, |
| ], |
| }); |
| let buffer113 = device0.createBuffer({ |
| size: 589, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView184 = texture127.createView({dimension: '1d', mipLevelCount: 1}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame17}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup48, [256]); |
| } catch {} |
| try { |
| renderPassEncoder6.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer48, 4_588); |
| } catch {} |
| try { |
| commandEncoder167.resolveQuerySet(querySet1, 9, 0, buffer35, 768); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer70, 1724, new Int16Array(1724), 83, 632); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 4, height: 1575, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture96, |
| mipLevel: 0, |
| origin: {x: 0, y: 458, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); }; |
| } catch {} |
| try { |
| await promise28; |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let commandEncoder185 = device0.createCommandEncoder({}); |
| let commandBuffer18 = commandEncoder167.finish(); |
| let textureView185 = texture47.createView({mipLevelCount: 2}); |
| try { |
| computePassEncoder67.setBindGroup(2, bindGroup12, new Uint32Array(450), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(23); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline23); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder185.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2588 */ |
| offset: 2588, |
| buffer: buffer55, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder185.copyTextureToBuffer({ |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 0, y: 72, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 960 */ |
| offset: 960, |
| bytesPerRow: 26880, |
| buffer: buffer35, |
| }, {width: 0, height: 113, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline28 = await promise19; |
| let imageData20 = new ImageData(100, 16); |
| let commandEncoder186 = device1.createCommandEncoder({}); |
| let textureView186 = texture175.createView({dimension: '2d-array'}); |
| let computePassEncoder192 = commandEncoder172.beginComputePass({}); |
| try { |
| computePassEncoder152.setBindGroup(2, bindGroup78, [0]); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer93, 'uint16', 434, 2_143); |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 202, resource: textureView0}, {binding: 47, resource: textureView1}], |
| }); |
| let sampler119 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 83.49, |
| compare: 'not-equal', |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder103.setBindGroup(0, bindGroup91, new Uint32Array(905), 148, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle16, renderBundle13]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer42, 2_744); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer66, 'uint32', 1_440, 50); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline28); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| try { |
| commandEncoder185.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 384 */ |
| offset: 384, |
| bytesPerRow: 9472, |
| buffer: buffer89, |
| }, { |
| texture: texture136, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder185.clearBuffer(buffer27, 404, 652); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| } catch {} |
| let commandEncoder187 = device1.createCommandEncoder({label: '\u0820\u0a7c\u{1fd58}\ua569\u0964\ucd2e\u8d70\u0d7b\u0d41\u{1f710}'}); |
| let querySet27 = device1.createQuerySet({type: 'occlusion', count: 499}); |
| let renderPassEncoder14 = commandEncoder187.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView186, |
| clearValue: { r: -840.5, g: 295.1, b: 147.1, a: 230.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer111, 'uint16', 3_138, 722); |
| } catch {} |
| let bindGroup98 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout21, |
| entries: [ |
| {binding: 55, resource: {buffer: buffer77, offset: 5120, size: 6413}}, |
| {binding: 70, resource: {buffer: buffer100, offset: 6912, size: 4667}}, |
| {binding: 42, resource: {buffer: buffer93, offset: 1024, size: 915}}, |
| ], |
| }); |
| let buffer114 = device1.createBuffer({size: 10474, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let querySet28 = device1.createQuerySet({type: 'occlusion', count: 264}); |
| try { |
| computePassEncoder139.setBindGroup(3, bindGroup72, [2048]); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup98); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup79, new Uint32Array(508), 186, 1); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(165).fill(5), /* required buffer size: 165 */ |
| {offset: 165, bytesPerRow: 228}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let offscreenCanvas6 = new OffscreenCanvas(110, 91); |
| let commandEncoder188 = device1.createCommandEncoder({}); |
| let texture205 = device1.createTexture({ |
| size: [4, 4, 18], |
| dimension: '2d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView187 = texture196.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder13.beginOcclusionQuery(150); |
| } catch {} |
| try { |
| renderPassEncoder13.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder180.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1104 */ |
| offset: 1104, |
| bytesPerRow: 7424, |
| buffer: buffer96, |
| }, { |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup99 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 454, resource: {buffer: buffer100, offset: 2304, size: 3683}}, |
| {binding: 106, resource: {buffer: buffer95, offset: 256}}, |
| {binding: 162, resource: {buffer: buffer92, offset: 768}}, |
| {binding: 21, resource: textureView136}, |
| ], |
| }); |
| let texture206 = device1.createTexture({ |
| size: [280, 5, 42], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView188 = texture186.createView({mipLevelCount: 1}); |
| let renderPassEncoder15 = commandEncoder188.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView186, |
| clearValue: { r: 661.7, g: -193.5, b: -65.73, a: -212.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder153.setBindGroup(0, bindGroup79, new Uint32Array(3443), 1_043, 1); |
| } catch {} |
| try { |
| renderPassEncoder15.setViewport(0.9710071688809843, 37.32916818875295, 0.010235532062389934, 37.23868788164302, 0.19398307019083105, 0.42275135319659923); |
| } catch {} |
| let gpuCanvasContext7 = offscreenCanvas6.getContext('webgpu'); |
| let bindGroup100 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [ |
| {binding: 251, resource: {buffer: buffer86, offset: 0, size: 5440}}, |
| {binding: 177, resource: {buffer: buffer86, offset: 2816, size: 1164}}, |
| ], |
| }); |
| let texture207 = device1.createTexture({ |
| label: '\u8e15\u938c\u{1feb7}\ueae8', |
| size: {width: 4, height: 320, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder193 = commandEncoder173.beginComputePass(); |
| let sampler120 = device1.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 89.14}); |
| try { |
| computePassEncoder188.setBindGroup(1, bindGroup75, new Uint32Array(2649), 221, 1); |
| } catch {} |
| try { |
| commandEncoder178.copyBufferToBuffer(buffer95, 1164, buffer99, 2788, 948); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let buffer115 = device1.createBuffer({ |
| size: 22333, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture208 = device1.createTexture({ |
| size: [4, 320, 1], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView189 = texture181.createView({label: '\u0abf\u061d\u0b76\u5121\ufbf3\u063e', arrayLayerCount: 5}); |
| let computePassEncoder194 = commandEncoder178.beginComputePass({}); |
| let sampler121 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.85, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder170.setBindGroup(3, bindGroup79, [1280]); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup98, new Uint32Array(2700), 1_126, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setScissorRect(0, 1, 0, 3); |
| } catch {} |
| try { |
| renderPassEncoder15.setViewport(0.17609350020148062, 16.06198019914924, 0.3855186026478021, 21.721764970065987, 0.535051820044888, 0.8953923029870379); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer76, 'uint16', 242, 103); |
| } catch {} |
| try { |
| commandEncoder186.copyBufferToBuffer(buffer111, 200, buffer78, 312, 40); |
| } catch {} |
| try { |
| commandEncoder182.copyTextureToTexture({ |
| texture: texture193, |
| mipLevel: 0, |
| origin: {x: 454, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img1); |
| let commandEncoder189 = device1.createCommandEncoder(); |
| let texture209 = device1.createTexture({ |
| label: '\ub88b\u0686\u{1ff42}', |
| size: {width: 4, height: 4, depthOrArrayLayers: 18}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup98, new Uint32Array(2790), 1_609, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer77, 'uint16', 1_118, 5_323); |
| } catch {} |
| let bindGroup101 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [ |
| {binding: 106, resource: {buffer: buffer86, offset: 256, size: 1824}}, |
| {binding: 162, resource: {buffer: buffer92, offset: 1280, size: 1792}}, |
| {binding: 454, resource: {buffer: buffer114, offset: 256, size: 1354}}, |
| {binding: 21, resource: textureView156}, |
| ], |
| }); |
| let textureView190 = texture209.createView({dimension: 'cube', aspect: 'all', baseArrayLayer: 1}); |
| let textureView191 = texture183.createView({}); |
| let computePassEncoder195 = commandEncoder182.beginComputePass({}); |
| let renderBundleEncoder18 = device1.createRenderBundleEncoder({colorFormats: ['rg32uint'], sampleCount: 1}); |
| try { |
| computePassEncoder149.setBindGroup(2, bindGroup72, [0]); |
| } catch {} |
| try { |
| computePassEncoder170.setBindGroup(0, bindGroup75, new Uint32Array(274), 44, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup79, new Uint32Array(1376), 8, 1); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); }; |
| } catch {} |
| document.body.append(canvas2); |
| let querySet29 = device1.createQuerySet({type: 'occlusion', count: 366}); |
| let textureView192 = texture208.createView({}); |
| let textureView193 = texture164.createView({aspect: 'all'}); |
| let computePassEncoder196 = commandEncoder189.beginComputePass({}); |
| let renderBundle18 = renderBundleEncoder18.finish({}); |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup98); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer95, 664, 592); |
| } catch {} |
| try { |
| device1.pushErrorScope('internal'); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let computePassEncoder197 = commandEncoder186.beginComputePass(); |
| let sampler122 = device1.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', compare: 'less'}); |
| let externalTexture15 = device1.importExternalTexture({source: videoFrame14, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder193.setBindGroup(1, bindGroup101, [1280]); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle17]); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(4, undefined, 0, 307_785_885); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture201, |
| mipLevel: 1, |
| origin: {x: 0, y: 51, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(676).fill(252), /* required buffer size: 676 */ |
| {offset: 676, bytesPerRow: 149, rowsPerImage: 64}, {width: 0, height: 29, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup102 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer92, offset: 0}}, |
| {binding: 21, resource: textureView136}, |
| {binding: 454, resource: {buffer: buffer93, offset: 0, size: 252}}, |
| {binding: 106, resource: {buffer: buffer95, offset: 1024}}, |
| ], |
| }); |
| let commandEncoder190 = device1.createCommandEncoder({}); |
| let texture210 = device1.createTexture({ |
| size: {width: 4, height: 320, depthOrArrayLayers: 207}, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder139.setBindGroup(0, bindGroup72, new Uint32Array(440), 40, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup101, new Uint32Array(746), 197, 1); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(2, buffer83); |
| } catch {} |
| try { |
| commandEncoder190.copyBufferToTexture({ |
| /* bytesInLastRow: 104 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1912 */ |
| offset: 1912, |
| buffer: buffer91, |
| }, { |
| texture: texture187, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder180.copyTextureToBuffer({ |
| texture: texture195, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 912 */ |
| offset: 912, |
| buffer: buffer77, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder170.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.append(canvas3); |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let texture211 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let sampler123 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 81.82, |
| compare: 'greater', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder133.setBindGroup(0, bindGroup7, new Uint32Array(1878), 376, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(33, 0, 2_072_439_338, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer42, 940); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline25); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder185.copyBufferToBuffer(buffer16, 24, buffer17, 3472, 368); |
| } catch {} |
| try { |
| buffer53.label = '\u1cf5\ua0d6\u{1fd81}\u{1fc36}\u00bc'; |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let texture212 = device0.createTexture({ |
| size: {width: 3357}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb'], |
| }); |
| let sampler124 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'linear', compare: 'never'}); |
| try { |
| computePassEncoder109.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(124, 0, 578_172_680); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer105, 'uint16', 486, 125); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder193 = device1.createCommandEncoder({}); |
| let computePassEncoder198 = commandEncoder190.beginComputePass({}); |
| let renderPassEncoder16 = commandEncoder193.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView186, |
| clearValue: { r: 66.97, g: -696.3, b: 404.2, a: -374.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 86602831, |
| }); |
| try { |
| computePassEncoder197.setBindGroup(0, bindGroup94, [768]); |
| } catch {} |
| try { |
| computePassEncoder147.insertDebugMarker('\ue782'); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let imageBitmap3 = await createImageBitmap(imageData3); |
| let bindGroup103 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [{binding: 174, resource: {buffer: buffer26, offset: 768, size: 2276}}], |
| }); |
| let commandBuffer19 = commandEncoder149.finish(); |
| let computePassEncoder199 = commandEncoder192.beginComputePass({}); |
| try { |
| computePassEncoder199.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup16, new Uint32Array(2403), 879, 1); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle15, renderBundle15, renderBundle15, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer22, 1_628); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer18]); |
| } catch {} |
| try { |
| await promise29; |
| } catch {} |
| let buffer116 = device0.createBuffer({size: 4205, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandBuffer20 = commandEncoder100.finish(); |
| let texture213 = device0.createTexture({ |
| size: [1, 393, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder200 = commandEncoder191.beginComputePass({}); |
| try { |
| computePassEncoder200.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup81); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder10.setBlendConstant({ r: -76.75, g: 295.4, b: -452.8, a: -302.0, }); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer47, 520); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer19, commandBuffer20]); |
| } catch {} |
| let imageData21 = new ImageData(12, 8); |
| let bindGroup104 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer86, offset: 0, size: 1244}}, |
| {binding: 21, resource: textureView156}, |
| {binding: 454, resource: {buffer: buffer100, offset: 768, size: 5932}}, |
| {binding: 106, resource: {buffer: buffer95, offset: 5120, size: 9720}}, |
| ], |
| }); |
| let buffer117 = device1.createBuffer({ |
| size: 12583, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView194 = texture144.createView({dimension: '2d-array'}); |
| let computePassEncoder201 = commandEncoder180.beginComputePass({}); |
| try { |
| computePassEncoder160.setBindGroup(0, bindGroup72, [256]); |
| } catch {} |
| let textureView195 = texture83.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder104); computePassEncoder104.dispatchWorkgroups(4, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer106, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 21} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 4, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 47, y: 46, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup105 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [ |
| {binding: 177, resource: {buffer: buffer117, offset: 512, size: 3744}}, |
| {binding: 251, resource: {buffer: buffer115, offset: 0, size: 12368}}, |
| ], |
| }); |
| let commandEncoder194 = device1.createCommandEncoder({}); |
| let computePassEncoder202 = commandEncoder194.beginComputePass(); |
| let sampler125 = device1.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 87.25, compare: 'less'}); |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup105); |
| } catch {} |
| let buffer118 = device1.createBuffer({ |
| size: 4516, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder195 = device1.createCommandEncoder(); |
| let computePassEncoder203 = commandEncoder195.beginComputePass({}); |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup101, new Uint32Array(3), 0, 1); |
| } catch {} |
| try { |
| buffer86.unmap(); |
| } catch {} |
| document.body.prepend(canvas3); |
| try { |
| commandEncoder80.label = '\u{1fce9}\ubdf2'; |
| } catch {} |
| let commandEncoder196 = device0.createCommandEncoder({}); |
| let textureView196 = texture0.createView({}); |
| let renderPassEncoder17 = commandEncoder196.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView130, |
| clearValue: { r: -274.2, g: -253.9, b: 395.0, a: -666.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder11.setViewport(1.6824527286332422, 798.879080059006, 1.5276738040561508, 330.9328760539084, 0.5638062345446748, 0.7439704575041617); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer113, 'uint32', 0, 189); |
| } catch {} |
| let promise30 = shaderModule2.getCompilationInfo(); |
| let arrayBuffer15 = buffer32.getMappedRange(0, 4); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 4, height: 1575, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData17, |
| origin: { x: 0, y: 14 }, |
| flipY: true, |
| }, { |
| texture: texture119, |
| mipLevel: 0, |
| origin: {x: 0, y: 887, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let textureView197 = texture86.createView({aspect: 'stencil-only', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 11}); |
| let computePassEncoder204 = commandEncoder185.beginComputePass({}); |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup8, new Uint32Array(81), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(2, buffer44, 0); |
| } catch {} |
| let bindGroup106 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout17, |
| entries: [{binding: 174, resource: {buffer: buffer40, offset: 0, size: 348}}], |
| }); |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let texture214 = device0.createTexture({ |
| size: {width: 1, height: 393, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder205 = commandEncoder197.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroups(1, 3); }; |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle15, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(15, 0, 454_724_464); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(28, 0, 0, 458_431_463); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline23); |
| } catch {} |
| let pipeline29 = device0.createComputePipeline({layout: pipelineLayout8, compute: {module: shaderModule1}}); |
| let textureView198 = texture89.createView({dimension: 'cube', aspect: 'stencil-only', baseArrayLayer: 1}); |
| try { |
| computePassEncoder71.setBindGroup(0, bindGroup61, [1280]); |
| } catch {} |
| try { |
| computePassEncoder205.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup4, [0]); |
| } catch {} |
| try { |
| renderPassEncoder12.draw(65, 100, 2_166_720_532, 147_453_799); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer67, 624); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline28); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| let promise31 = device0.createRenderPipelineAsync({ |
| layout: pipelineLayout11, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment3', |
| constants: {}, |
| targets: [{ |
| format: 'bgra8unorm', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule5, |
| entryPoint: 'vertex5', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 272, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 4, shaderLocation: 7}, |
| {format: 'snorm16x2', offset: 124, shaderLocation: 6}, |
| {format: 'float16x4', offset: 16, shaderLocation: 3}, |
| {format: 'snorm8x4', offset: 36, shaderLocation: 14}, |
| {format: 'unorm16x4', offset: 24, shaderLocation: 1}, |
| {format: 'sint32x2', offset: 24, shaderLocation: 10}, |
| {format: 'float16x4', offset: 24, shaderLocation: 12}, |
| {format: 'uint8x4', offset: 112, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 12, shaderLocation: 8}, |
| {format: 'float32x3', offset: 32, shaderLocation: 11}, |
| {format: 'float32', offset: 12, shaderLocation: 2}, |
| {format: 'float32', offset: 32, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 12, shaderLocation: 15}, |
| ], |
| }, |
| {arrayStride: 32, attributes: [{format: 'sint32', offset: 4, shaderLocation: 4}]}, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw'}, |
| }); |
| let buffer119 = device0.createBuffer({size: 8938, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let texture215 = device0.createTexture({ |
| size: [2, 787, 1], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView199 = texture95.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| computePassEncoder204.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup84, [512]); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup15, new Uint32Array(468), 133, 1); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer70, 748, 2_204); |
| } catch {} |
| let arrayBuffer16 = buffer32.getMappedRange(1968, 820); |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| /* used global variables: buffer120 */ |
| fn fn0() -> array<array<FragmentOutput6, 1>, 1> { |
| var out: array<array<FragmentOutput6, 1>, 1>; |
| var vf116: f16 = determinant(mat3x3h(unconst_f16(54.69), unconst_f16(-3555.2), unconst_f16(4096.0), unconst_f16(11924.0), unconst_f16(1867.2), unconst_f16(1328.5), unconst_f16(3888.9), unconst_f16(13883.7), unconst_f16(18555.8))); |
| atomicAnd(&vw29[30][unconst_u32(470)], unconst_i32(19)); |
| let ptr58: ptr<workgroup, u32> = &(*&vw30).f14; |
| vw27.f12 = vec4h((*&vw30).f13); |
| workgroupBarrier(); |
| let ptr59: ptr<storage, f16, read> = &(*&buffer120)[1][unconst_u32(18)][unconst_u32(91)]; |
| vw30 = VertexOutput7(vec4h(buffer120[unconst_u32(157)][0][10]), vec4f(f32(buffer120[unconst_u32(157)][0][10])), u32(buffer120[unconst_u32(157)][0][10])); |
| let ptr60: ptr<storage, array<array<f16, 11>, 1>, read> = &buffer120[unconst_u32(129)]; |
| return out; |
| _ = buffer120; |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw27: VertexOutput7; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw31: vec2u; |
| |
| struct FragmentOutput5 { |
| @location(5) f0: vec2i, |
| @location(0) f1: vec4f, |
| } |
| |
| /* used global variables: buffer120 */ |
| fn fn2() -> VertexOutput7 { |
| var out: VertexOutput7; |
| out.f13 += vec4f(f32(buffer120[unconst_u32(71)][unconst_u32(439)][10])); |
| var vf118: vec3h = sinh(vec3h(unconst_f16(10124.3), unconst_f16(6579.9), unconst_f16(-4326.2))); |
| let ptr73: ptr<function, vec3h> = &vf118; |
| let ptr74: ptr<storage, array<f16, 11>, read> = &buffer120[1][0]; |
| var vf119: mat4x2h = (mat4x2h(unconst_f16(10003.1), unconst_f16(7216.2), unconst_f16(38781.4), unconst_f16(5449.3), unconst_f16(23140.9), unconst_f16(615.0), unconst_f16(14639.5), unconst_f16(2995.3)) + mat4x2h((*&buffer120)[1][0][10], (*&buffer120)[1][0][10], (*&buffer120)[1][0][10], (*&buffer120)[1][0][10], (*&buffer120)[1][0][10], (*&buffer120)[1][0][10], (*&buffer120)[1][0][10], (*&buffer120)[1][0][10])); |
| out.f12 *= bitcast<vec4h>(sinh(vec2f(unconst_f32(0.03626), unconst_f32(0.3168)))); |
| let vf120: f16 = mix(unconst_f16(3896.3), unconst_f16(987.1), unconst_f16(4601.9)); |
| let ptr75: ptr<storage, f16, read> = &(*&buffer120)[unconst_u32(110)][0][unconst_u32(200)]; |
| loop { |
| while bool((*&buffer120)[1][0][10]) { |
| let ptr76: ptr<storage, array<array<array<f16, 11>, 1>, 2>, read> = &(*&buffer120); |
| let ptr77: ptr<storage, f16, read> = &(*ptr76)[unconst_u32(960)][u32((*ptr76)[unconst_u32(80)][0][10])][10]; |
| out.f13 += vec4f((vec3u(unconst_u32(295), unconst_u32(22), unconst_u32(42)) + vec3u(unconst_u32(70), unconst_u32(252), unconst_u32(151))).bggg); |
| let ptr78: ptr<storage, f16, read> = &(*&buffer120)[1][0][unconst_u32(309)]; |
| out.f13 = tan(vec2f(unconst_f32(0.1307), unconst_f32(-0.06744))).xxxy; |
| break; |
| _ = buffer120; |
| } |
| out.f13 = vec4f(f32((*&buffer120)[unconst_u32(120)][0][10])); |
| let ptr79: ptr<storage, f16, read> = &buffer120[unconst_u32(54)][unconst_u32(71)][10]; |
| break; |
| _ = buffer120; |
| } |
| let ptr80: ptr<storage, array<f16, 11>, read> = &buffer120[1][0]; |
| vp14 -= buffer120[unconst_u32(364)][0][unconst_u32(168)]; |
| return out; |
| _ = buffer120; |
| } |
| |
| struct VertexOutput7 { |
| @location(6) f12: vec4h, |
| @builtin(position) f13: vec4f, |
| @location(13) @interpolate(flat, center) f14: u32, |
| } |
| |
| var<private> vp14: f16 = f16(8085.2); |
| |
| var<private> vp13 = modf(vec2f(0.2888, 0.1115)); |
| |
| @group(0) @binding(174) var<storage, read> buffer120: array<array<array<f16, 11>, 1>, 2>; |
| |
| /* used global variables: buffer120 */ |
| fn fn1() -> vec2f { |
| var out: vec2f; |
| let ptr61: ptr<private, vec2f> = &vp13.whole; |
| for (var it6=u32(buffer120[1][0][10]); it6<u32(buffer120[unconst_u32(34)][0][10]); it6++) { |
| let ptr62: ptr<storage, f16, read> = &(*&buffer120)[unconst_u32(183)][unconst_u32(367)][unconst_u32(43)]; |
| let ptr63: ptr<storage, f16, read> = &(*&buffer120)[1][u32((*&buffer120)[1][unconst_u32(216)][10])][10]; |
| vp14 = buffer120[unconst_u32(48)][0][10]; |
| out = vec2f(f32((*&buffer120)[1][0][10])); |
| let ptr64: ptr<storage, f16, read> = &(*&buffer120)[u32((*&buffer120)[1][0][10])][0][10]; |
| break; |
| _ = buffer120; |
| } |
| let ptr65: ptr<storage, array<f16, 11>, read> = &(*&buffer120)[unconst_u32(290)][unconst_u32(23)]; |
| let ptr66: ptr<storage, array<array<f16, 11>, 1>, read> = &buffer120[unconst_u32(116)]; |
| let ptr67: ptr<storage, f16, read> = &(*&buffer120)[u32((*ptr66)[unconst_u32(49)][10])][unconst_u32(265)][unconst_u32(214)]; |
| let ptr68: ptr<storage, array<array<array<f16, 11>, 1>, 2>, read> = &buffer120; |
| out = vec2f(f32((*ptr68)[unconst_u32(404)][0][10])); |
| let ptr69: ptr<private, vec2f> = &vp13.whole; |
| let ptr70: ptr<storage, array<f16, 11>, read> = &(*ptr68)[1][unconst_u32(393)]; |
| vp14 = vec2h((*ptr69))[0]; |
| let ptr71: ptr<storage, array<f16, 11>, read> = &buffer120[1][unconst_u32(336)]; |
| let vf117: bool = (bool(pack4xI8(vec4i(unconst_i32(47), unconst_i32(219), unconst_i32(-132), unconst_i32(33)))) && unconst_bool(true)); |
| let ptr72: ptr<storage, f16, read> = &buffer120[unconst_u32(103)][u32((*&buffer120)[unconst_u32(143)][0][10])][10]; |
| vp13 = modf(unpack2x16unorm(pack4x8snorm(vec4f(unconst_f32(0.2874), unconst_f32(0.08369), unconst_f32(0.02630), unconst_f32(0.00398))))); |
| vp14 = buffer120[unconst_u32(77)][unconst_u32(24)][10]; |
| return out; |
| _ = buffer120; |
| } |
| |
| var<workgroup> vw28: atomic<u32>; |
| |
| var<workgroup> vw29: array<array<atomic<i32>, 2>, 31>; |
| |
| struct FragmentOutput6 { |
| @location(0) @interpolate(flat) f0: vec4i, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw30: VertexOutput7; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| @size(48) f0: array<vec2i>, |
| } |
| |
| /* used global variables: buffer120 */ |
| @vertex |
| fn vertex7(@location(1) @interpolate(flat, sample) a0: vec2i) -> VertexOutput7 { |
| var out: VertexOutput7; |
| let ptr81: ptr<storage, array<array<f16, 11>, 1>, read> = &(*&buffer120)[1]; |
| vp13.fract *= vec2f(f32((*&buffer120)[1][0][10])); |
| vp14 -= buffer120[1][0][10]; |
| fn2(); |
| out.f12 += vec4h((*&buffer120)[1][unconst_u32(139)][10]); |
| let ptr82: ptr<storage, array<array<f16, 11>, 1>, read> = &buffer120[1]; |
| out.f12 -= vec4h((*&buffer120)[unconst_u32(201)][unconst_u32(80)][10]); |
| var vf121: vec4h = cos(vec4h(unconst_f16(4833.2), unconst_f16(-8472.5), unconst_f16(2426.1), unconst_f16(16082.4))); |
| let ptr83: ptr<storage, f16, read> = &(*ptr81)[0][unconst_u32(59)]; |
| var vf122 = fn2(); |
| fn2(); |
| let ptr84: ptr<storage, array<array<f16, 11>, 1>, read> = &(*&buffer120)[1]; |
| return out; |
| _ = buffer120; |
| } |
| |
| /* used global variables: buffer120 */ |
| @fragment |
| fn fragment8(@location(7) a0: vec2f) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| fn1(); |
| out.f0 -= vec2i(refract(vec3f(unconst_f32(0.01249), unconst_f32(0.5625), unconst_f32(0.08390)), vec3f(unconst_f32(0.1028), unconst_f32(-0.09129), unconst_f32(0.01979)), unconst_f32(0.00955)).yz); |
| let ptr85: ptr<storage, f16, read> = &buffer120[unconst_u32(47)][unconst_u32(83)][10]; |
| var vf123 = fn1(); |
| vp14 = f16(vf123[unconst_u32(254)]); |
| return out; |
| _ = buffer120; |
| } |
| |
| /* used global variables: buffer120 */ |
| @fragment |
| fn fragment9(@builtin(front_facing) a0: bool) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| if bool(pack4xU8Clamp( ~vec4u(u32(buffer120[unconst_u32(83)][0][unconst_u32(125)])))) { |
| let ptr86: ptr<storage, f16, read> = &buffer120[1][0][unconst_u32(85)]; |
| vp13 = modf(unpack2x16float(u32(buffer120[unconst_u32(20)][0][10]))); |
| _ = buffer120; |
| } |
| let ptr87: ptr<storage, f16, read> = &buffer120[1][0][unconst_u32(69)]; |
| out.f0 = vec4i(i32(buffer120[1][unconst_u32(90)][unconst_u32(203)])); |
| let ptr88: ptr<storage, array<array<array<f16, 11>, 1>, 2>, read> = &(*&buffer120); |
| fn1(); |
| switch i32((*ptr87)) { |
| default { |
| let ptr89: ptr<storage, array<f16, 11>, read> = &(*&buffer120)[1][0]; |
| var vf124 = fn1(); |
| while bool(countOneBits(unconst_u32(272))) { |
| let ptr90: ptr<storage, f16, read> = &buffer120[unconst_u32(157)][0][unconst_u32(395)]; |
| fn1(); |
| break; |
| _ = buffer120; |
| } |
| out.f0 = vec4i(atan(vec3h(buffer120[u32(transpose(mat4x3f(f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)]), f32(buffer120[1][0][unconst_u32(93)])))[unconst_i32(2)].w)][0][10])).xxyx); |
| _ = buffer120; |
| } |
| } |
| let ptr91: ptr<storage, array<array<array<f16, 11>, 1>, 2>, read> = &buffer120; |
| var vf125 = fn1(); |
| var vf126 = fn1(); |
| out.f0 *= vec4i(i32((*ptr88)[1][0][10])); |
| fn1(); |
| let vf127: vec3i = (vec3i(unconst_i32(121), unconst_i32(223), unconst_i32(54)) >> vec3u(unconst_u32(14), unconst_u32(133), unconst_u32(254))); |
| var vf128 = fn1(); |
| var vf129: vec3i = (vec3i(select(vec4u(u32(buffer120[unconst_u32(2)][0][10])), unpack4xU8(u32((*&buffer120)[unconst_u32(285)][unconst_u32(1)][unconst_u32(123)])), unconst_bool(true)).baa) >> vec3u(unconst_u32(123), unconst_u32(22), unconst_u32(31))); |
| return out; |
| _ = buffer120; |
| } |
| |
| /* used global variables: buffer120 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute6() { |
| var vf130 = fn0(); |
| var vf131 = fn2(); |
| var vf132 = fn2(); |
| atomicStore(&vw29[unconst_u32(145)][unconst_u32(132)], unconst_i32(22)); |
| fn0(); |
| fn0(); |
| var vf133 = fn0(); |
| vw30 = VertexOutput7(vec4h(buffer120[unconst_u32(99)][0][unconst_u32(468)]), vec4f(f32(buffer120[unconst_u32(99)][0][unconst_u32(468)])), u32(buffer120[unconst_u32(99)][0][unconst_u32(468)])); |
| fn0(); |
| fn0(); |
| let ptr92: ptr<function, vec4i> = &vf133[unconst_u32(67)][0].f0; |
| _ = buffer120; |
| }`, |
| }); |
| let textureView200 = texture41.createView({format: 'r16sint', mipLevelCount: 1}); |
| let sampler126 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| renderPassEncoder8.setViewport(1.8285745795133959, 439.27078502680985, 0.09161390613022988, 356.2805215745462, 0.3519418615437552, 0.7536146762468909); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer60, 5_168); |
| } catch {} |
| let buffer121 = device0.createBuffer({ |
| size: 2066, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture216 = device0.createTexture({ |
| size: {width: 419, height: 1, depthOrArrayLayers: 25}, |
| mipLevelCount: 2, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder156.setBindGroup(0, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup64, [512]); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(275, 15, 804_408_116, 365_566_343); |
| } catch {} |
| try { |
| computePassEncoder172.pushDebugGroup('\u{1fd03}'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 21} |
| */ |
| { |
| source: offscreenCanvas4, |
| origin: { x: 9, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 37, y: 27, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'iec6196624'} }); |
| let commandEncoder198 = device1.createCommandEncoder({}); |
| let texture217 = device1.createTexture({ |
| size: [8, 640, 1], |
| sampleCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView201 = texture206.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder203.setBindGroup(1, bindGroup105, new Uint32Array(1126), 72, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup79, new Uint32Array(1377), 20, 1); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle14]); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(1, buffer100, 0); |
| } catch {} |
| try { |
| commandEncoder198.copyBufferToTexture({ |
| /* bytesInLastRow: 864 widthInBlocks: 54 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 2544 */ |
| offset: 2544, |
| buffer: buffer112, |
| }, { |
| texture: texture181, |
| mipLevel: 0, |
| origin: {x: 633, y: 0, z: 3}, |
| aspect: 'all', |
| }, {width: 54, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| let shaderModule9 = device1.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| struct T1 { |
| @align(128) @size(4992) f0: array<u32>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw32: mat2x3f; |
| |
| struct VertexOutput8 { |
| @location(6) @interpolate(flat, either) f15: vec4u, |
| @location(4) @interpolate(flat) f16: vec2i, |
| @location(9) f17: vec4f, |
| @builtin(position) f18: vec4f, |
| } |
| |
| struct T0 { |
| @align(16) @size(80) f0: array<u32>, |
| } |
| |
| @id(6875) override override13: f32; |
| |
| override override14: u32 = 25; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex8(@location(11) a0: vec4f, @location(6) a1: i32, @location(2) @interpolate(linear) a2: vec2h, @location(15) a3: i32, @location(7) @interpolate(linear) a4: vec2h, @location(9) a5: f32, @location(5) a6: vec4u, @location(12) a7: vec4h, @location(13) @interpolate(flat) a8: vec2u) -> VertexOutput8 { |
| var out: VertexOutput8; |
| var vf134: f16 = a2[unconst_u32(7)]; |
| var vf135: vec2u = a8; |
| vf134 -= f16( ~unconst_i32(-33)); |
| var vf136: vec3f = cross(vec3f(unconst_f32(-0.1866), unconst_f32(0.1797), unconst_f32(-0.03992)), vec3f(unconst_f32(-0.07958), unconst_f32(0.04214), unconst_f32(0.5497))); |
| vf134 = f16(vf136[unconst_u32(46)]); |
| let vf137: f16 = a4[unconst_u32(366)]; |
| out.f17 -= vec4f(bitcast<f32>(a1)); |
| if bool(a5) { |
| let vf138: f16 = a4[unconst_u32(314)]; |
| var vf139: vec3f = cross(vec3f(unconst_f32(0.04941), unconst_f32(0.02930), unconst_f32(0.7701)), vec3f(bitcast<f32>(countTrailingZeros(unconst_u32(378))))); |
| var vf140: u32 = pack2x16snorm(vec2f(unconst_f32(0.3310), unconst_f32(0.3633))); |
| } |
| let vf141: f32 = vf136[unconst_u32(119)]; |
| let vf142: vec4u = unpack4xU8(unconst_u32(83)); |
| return out; |
| }`, |
| }); |
| let computePassEncoder206 = commandEncoder198.beginComputePass({}); |
| try { |
| computePassEncoder153.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setScissorRect(0, 12, 0, 32); |
| } catch {} |
| try { |
| commandEncoder136.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 144 */ |
| offset: 144, |
| bytesPerRow: 15616, |
| buffer: buffer91, |
| }, { |
| texture: texture171, |
| mipLevel: 1, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView202 = texture172.createView({arrayLayerCount: 1}); |
| let sampler127 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 5, |
| }); |
| let buffer124 = device1.createBuffer({size: 314, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture218 = device1.createTexture({ |
| size: {width: 528, height: 40, depthOrArrayLayers: 4}, |
| mipLevelCount: 4, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rgba8unorm-srgb'], |
| }); |
| let computePassEncoder207 = commandEncoder136.beginComputePass({}); |
| try { |
| computePassEncoder193.setBindGroup(3, bindGroup104, new Uint32Array(385), 39, 1); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup98, new Uint32Array(388), 21, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer95, 'uint32', 916, 6_147); |
| } catch {} |
| let textureView203 = texture30.createView({label: '\ubf3d\u{1f6c6}\u0ba2\u708c\ue20f\u83d0\u{1ff1a}', format: 'r16sint'}); |
| let sampler128 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 64.44, |
| compare: 'less', |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup8, new Uint32Array(1133), 364, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder12.draw(56, 243, 1_837_023_873, 146_916_677); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline25); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| document.body.prepend(canvas2); |
| let bindGroup107 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 59, resource: textureView111}]}); |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup97); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(7, 51, 13, 1_267_600_217, 3_209_776_663); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await promise30; |
| } catch {} |
| let videoFrame22 = new VideoFrame(canvas3, {timestamp: 0}); |
| try { |
| computePassEncoder203.setBindGroup(2, bindGroup75, new Uint32Array(837), 196, 1); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(4, buffer118); |
| } catch {} |
| let commandEncoder199 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder67.setBindGroup(1, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(193, 66, 33, 92_518_891, 34_016_484); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer16, 28); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer89, 6_736); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer113, 'uint32', 40, 20); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer69, 0, 9_263); |
| } catch {} |
| try { |
| buffer14.unmap(); |
| } catch {} |
| try { |
| commandEncoder199.copyBufferToBuffer(buffer46, 5136, buffer42, 2540, 16); |
| } catch {} |
| try { |
| commandEncoder199.resolveQuerySet(querySet3, 80, 95, buffer108, 4608); |
| } catch {} |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 79, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 209, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let computePassEncoder208 = commandEncoder199.beginComputePass({}); |
| let sampler129 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat', maxAnisotropy: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer71, 748); }; |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(85, 72, 199_279_722, 1_602_554_203); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(71, 92, 23, 83_068_577, 1_803_341_348); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer84, 1_388); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer49, 420, 424); |
| } catch {} |
| try { |
| computePassEncoder13.insertDebugMarker('\u434c'); |
| } catch {} |
| document.body.append(img0); |
| let buffer125 = device0.createBuffer({ |
| size: 2118, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView204 = texture131.createView({}); |
| try { |
| computePassEncoder124.setBindGroup(0, bindGroup60, new Uint32Array(1354), 34, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder80); computePassEncoder80.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder208.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer42, 8_088); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer31, 'uint32', 32, 319); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(1, buffer28, 0, 4_059); |
| } catch {} |
| try { |
| computePassEncoder196.setBindGroup(1, bindGroup105, new Uint32Array(1542), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup79, [768]); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup93, new Uint32Array(1250), 64, 1); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle14, renderBundle18, renderBundle17]); |
| } catch {} |
| let promise32 = device1.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let commandEncoder200 = device0.createCommandEncoder({}); |
| let computePassEncoder209 = commandEncoder200.beginComputePass({}); |
| try { |
| computePassEncoder80.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup89, new Uint32Array(1151), 40, 1); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer113, 144); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer72, 1_488); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer42, 'uint32', 4_672, 6_259); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder12.insertDebugMarker('\u42b7'); |
| } catch {} |
| let bindGroup108 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [{binding: 174, resource: {buffer: buffer71, offset: 256, size: 396}}], |
| }); |
| let buffer126 = device0.createBuffer({size: 7664, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder201 = device0.createCommandEncoder({}); |
| let sampler130 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 80.73, |
| compare: 'not-equal', |
| maxAnisotropy: 17, |
| }); |
| try { |
| renderPassEncoder9.draw(33, 18, 1_752_993_649, 391_220_613); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer26, 108); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer42, 1_896); |
| } catch {} |
| try { |
| commandEncoder201.copyBufferToTexture({ |
| /* bytesInLastRow: 160 widthInBlocks: 80 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 374 */ |
| offset: 374, |
| buffer: buffer125, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 80, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder202 = device1.createCommandEncoder({}); |
| let texture219 = device1.createTexture({ |
| size: [280], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| commandEncoder202.copyBufferToBuffer(buffer91, 816, buffer78, 96, 76); |
| } catch {} |
| try { |
| commandEncoder202.copyTextureToBuffer({ |
| texture: texture217, |
| mipLevel: 0, |
| origin: {x: 0, y: 126, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 6368 */ |
| offset: 6368, |
| bytesPerRow: 1792, |
| buffer: buffer82, |
| }, {width: 0, height: 24, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder167.insertDebugMarker('\u{1fd3f}'); |
| } catch {} |
| let bindGroup109 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout19, |
| entries: [ |
| {binding: 162, resource: {buffer: buffer92, offset: 512}}, |
| {binding: 21, resource: textureView141}, |
| {binding: 106, resource: {buffer: buffer86, offset: 768, size: 1756}}, |
| {binding: 454, resource: {buffer: buffer83, offset: 0, size: 91}}, |
| ], |
| }); |
| try { |
| computePassEncoder188.setBindGroup(2, bindGroup93, new Uint32Array(3739), 649, 1); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(3, buffer83); |
| } catch {} |
| try { |
| commandEncoder202.copyBufferToBuffer(buffer87, 2852, buffer118, 448, 352); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 70, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView205 = texture98.createView({dimension: 'cube', mipLevelCount: 1}); |
| let textureView206 = texture42.createView({}); |
| let computePassEncoder210 = commandEncoder79.beginComputePass({}); |
| try { |
| computePassEncoder96.setBindGroup(0, bindGroup31, new Uint32Array(172), 44, 1); |
| } catch {} |
| try { |
| computePassEncoder210.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(142, 19, 1_423_392_689, 311_798_531); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(272, 52, 0, -1_884_297_047, 1_048_897_513); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 1128, new DataView(new ArrayBuffer(10681)), 961, 1604); |
| } catch {} |
| try { |
| renderPassEncoder15.setViewport(0.7161090058163561, 15.38097428534444, 0.21426616053877823, 60.902008160815015, 0.7014723024100024, 0.7838329285240132); |
| } catch {} |
| try { |
| buffer99.unmap(); |
| } catch {} |
| try { |
| commandEncoder202.copyBufferToTexture({ |
| /* bytesInLastRow: 144 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 5440 */ |
| offset: 5440, |
| bytesPerRow: 55296, |
| rowsPerImage: 46, |
| buffer: buffer95, |
| }, { |
| texture: texture172, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer127 = device1.createBuffer({ |
| size: 8289, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder203 = device1.createCommandEncoder({}); |
| let texture220 = device1.createTexture({ |
| size: [528, 40, 246], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder211 = commandEncoder203.beginComputePass(); |
| let renderPassEncoder18 = commandEncoder202.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView182, |
| depthSlice: 10, |
| clearValue: { r: -35.28, g: -393.3, b: -437.2, a: -201.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 144254806, |
| }); |
| let sampler131 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder192.setBindGroup(0, bindGroup100, new Uint32Array(709), 137, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer95, 'uint16', 1_974, 880); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(3, buffer117); |
| } catch {} |
| try { |
| buffer112.unmap(); |
| } catch {} |
| let bindGroup110 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout21, |
| entries: [ |
| {binding: 42, resource: {buffer: buffer76, offset: 0}}, |
| {binding: 55, resource: {buffer: buffer77, offset: 1792, size: 6585}}, |
| {binding: 70, resource: {buffer: buffer114, offset: 1792, size: 1050}}, |
| ], |
| }); |
| let textureView207 = texture196.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let externalTexture16 = device1.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder177.setBindGroup(1, bindGroup93, [256]); |
| } catch {} |
| try { |
| renderPassEncoder13.beginOcclusionQuery(216); |
| } catch {} |
| let imageData22 = new ImageData(28, 120); |
| let texture221 = device1.createTexture({size: [4, 4, 18], format: 'rgba8unorm-srgb', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup93, [512]); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture207, |
| mipLevel: 1, |
| origin: {x: 0, y: 54, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(1).fill(109), /* required buffer size: 1 */ |
| {offset: 1, bytesPerRow: 58}, {width: 0, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup111 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 34, resource: textureView86}, |
| {binding: 28, resource: textureView71}, |
| {binding: 14, resource: sampler55}, |
| {binding: 495, resource: {buffer: buffer72, offset: 5120, size: 1100}}, |
| ], |
| }); |
| let buffer128 = device0.createBuffer({ |
| size: 6615, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder204 = device0.createCommandEncoder({}); |
| let computePassEncoder212 = commandEncoder201.beginComputePass({}); |
| let renderPassEncoder19 = commandEncoder204.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView204, |
| depthSlice: 2, |
| clearValue: { r: -264.8, g: 300.8, b: -297.5, a: 927.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 2967769, |
| }); |
| try { |
| renderPassEncoder5.executeBundles([renderBundle9, renderBundle9, renderBundle15, renderBundle15, renderBundle9, renderBundle15, renderBundle15, renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(19, 263, 1_162_063_234, 98_028_909); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(27, 61, 49, -1_878_851_309, 441_846_080); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer89, 3_100); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer11, 172); |
| } catch {} |
| let pipeline30 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, entryPoint: 'compute5'}}); |
| let bindGroup112 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout17, |
| entries: [ |
| {binding: 454, resource: {buffer: buffer77, offset: 4096, size: 5267}}, |
| {binding: 21, resource: textureView154}, |
| {binding: 162, resource: {buffer: buffer86, offset: 256, size: 1052}}, |
| {binding: 106, resource: {buffer: buffer115, offset: 19200, size: 1944}}, |
| ], |
| }); |
| let buffer129 = device1.createBuffer({ |
| size: 33730, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder205 = device1.createCommandEncoder({}); |
| let textureView208 = texture221.createView({dimension: '2d', aspect: 'all', format: 'rgba8unorm-srgb'}); |
| let computePassEncoder213 = commandEncoder205.beginComputePass(); |
| try { |
| computePassEncoder147.setBindGroup(1, bindGroup110); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup110); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup101, new Uint32Array(2000), 210, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer94, 'uint32', 36, 154); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({device: device1, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| } catch {} |
| await gc(); |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup113 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout26, |
| entries: [ |
| {binding: 6, resource: textureView143}, |
| {binding: 15, resource: {buffer: buffer17, offset: 768, size: 6832}}, |
| ], |
| }); |
| try { |
| renderPassEncoder17.setPipeline(pipeline23); |
| } catch {} |
| document.body.prepend(canvas3); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView209 = texture128.createView({dimension: '2d-array'}); |
| let texture222 = device0.createTexture({ |
| size: {width: 1, height: 547, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder104.end(); |
| } catch {} |
| try { |
| computePassEncoder209.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder5.beginOcclusionQuery(1); |
| } catch {} |
| try { |
| renderPassEncoder2.setScissorRect(0, 183, 0, 42); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(158, 210, 272_849_795, 284_970_289); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer113, 84); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await promise32; |
| } catch {} |
| let imageBitmap4 = await createImageBitmap(imageBitmap1); |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 6, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }}, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 11, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 12, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 13, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 17, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 18, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 23, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 24, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 25, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 26, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 27, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 28, visibility: GPUShaderStage.VERTEX, sampler: { type: 'filtering' }}, |
| { |
| binding: 29, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'non-filtering' }, |
| }, |
| {binding: 32, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| {binding: 33, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 34, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 36, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 37, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 38, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 40, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| {binding: 41, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 44, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 46, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true }, |
| }, |
| {binding: 47, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 49, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 50, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 51, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 54, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 56, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 58, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 63, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 64, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 67, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| {binding: 68, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 69, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 71, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 72, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| {binding: 74, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| {binding: 75, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 78, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 79, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 80, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 82, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| {binding: 85, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| { |
| binding: 86, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 87, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 92, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 94, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 97, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 98, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 100, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 103, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| {binding: 107, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 108, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 110, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 117, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| {binding: 119, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 125, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 134, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 135, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 137, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 138, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 150, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 153, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 157, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8unorm', access: 'write-only', viewDimension: '1d' }, |
| }, |
| {binding: 158, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 161, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 163, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| {binding: 164, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 166, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 167, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 175, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 176, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 181, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 183, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 194, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| {binding: 196, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 197, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 199, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 204, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 205, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}, |
| {binding: 206, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 208, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 213, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 221, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 226, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 231, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 232, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| {binding: 233, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 238, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| {binding: 242, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 243, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 252, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| {binding: 253, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| {binding: 257, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| {binding: 261, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 265, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 267, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 268, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 279, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 293, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 308, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 317, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 326, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 346, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 79, hasDynamicOffset: true }, |
| }, |
| {binding: 350, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 352, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 353, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 359, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 360, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 374, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 380, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 398, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 410, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| {binding: 432, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| {binding: 454, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 488, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 489, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 520, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 655, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 659, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 669, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let bindGroup114 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [{binding: 174, resource: {buffer: buffer25, offset: 512, size: 1968}}], |
| }); |
| let commandEncoder206 = device0.createCommandEncoder(); |
| let texture223 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 21}, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder101.setBindGroup(0, bindGroup16, [0]); |
| } catch {} |
| try { |
| computePassEncoder212.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder5.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle9, renderBundle15, renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(2.841695551377674, 1500.3041199305112, 1.1486339347716115, 33.48099874439807, 0.6742400234431164, 0.9962318296530792); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(128, 137, 73, -2_147_052_702, 508_534_201); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer113, 100); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline23); |
| } catch {} |
| try { |
| commandEncoder89.insertDebugMarker('\u3dfd'); |
| } catch {} |
| let buffer130 = device1.createBuffer({ |
| size: 702, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder207 = device1.createCommandEncoder(); |
| let textureView210 = texture209.createView({dimension: 'cube', baseArrayLayer: 1}); |
| let computePassEncoder214 = commandEncoder207.beginComputePass({}); |
| let renderBundleEncoder19 = device1.createRenderBundleEncoder({ |
| label: '\u2f6c\u6e6c\ue14b\u{1ff96}', |
| colorFormats: ['rg32uint'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let renderBundle19 = renderBundleEncoder19.finish({}); |
| try { |
| renderPassEncoder13.endOcclusionQuery(); |
| } catch {} |
| let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 7, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 111, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32float', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 140, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 224, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 291, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 313, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder208 = device0.createCommandEncoder({}); |
| let commandBuffer21 = commandEncoder89.finish(); |
| try { |
| computePassEncoder13.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder12.draw(0, 8, 199_116_378, 295_590_532); |
| } catch {} |
| let querySet30 = device1.createQuerySet({type: 'occlusion', count: 61}); |
| let textureView211 = texture221.createView({dimension: '2d', baseArrayLayer: 4}); |
| let textureView212 = texture144.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder16.setVertexBuffer(6, buffer129, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer92, 40, new DataView(new ArrayBuffer(8375)), 834, 1920); |
| } catch {} |
| let bindGroup115 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [{binding: 174, resource: {buffer: buffer34, offset: 6912, size: 228}}], |
| }); |
| let commandEncoder209 = device0.createCommandEncoder({}); |
| let computePassEncoder215 = commandEncoder209.beginComputePass({}); |
| let renderPassEncoder20 = commandEncoder208.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView150, |
| clearValue: { r: 550.3, g: -134.2, b: 173.7, a: -562.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder8.setViewport(1.6711211049127752, 348.12930004971713, 0.19746309502134474, 499.71618698435833, 0.44857995892063074, 0.9175439117178059); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(41, 38, 34, 813_689_218, 203_907_808); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline18); |
| } catch {} |
| try { |
| buffer38.unmap(); |
| } catch {} |
| try { |
| commandEncoder206.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 680 */ |
| offset: 680, |
| bytesPerRow: 5632, |
| buffer: buffer21, |
| }, { |
| texture: texture182, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule10 = device1.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct FragmentOutput7 { |
| @location(0) @interpolate(flat) f0: vec4u, |
| @location(7) f1: vec4i, |
| } |
| |
| var<private> vp17 = modf(vec3h(1188.7, 7486.6, 30851.2)); |
| |
| var<private> vp16: bool = bool(false); |
| |
| var<workgroup> vw34: vec2<bool>; |
| |
| var<workgroup> vw35: atomic<i32>; |
| |
| @group(0) @binding(177) var<storage, read_write> buffer131: T2; |
| |
| struct T1 { |
| @align(16) @size(240) f0: array<u32>, |
| } |
| |
| var<workgroup> vw33: mat3x3h; |
| |
| struct T2 { |
| @align(16) @size(240) f0: array<atomic<i32>>, |
| } |
| |
| var<private> vp18: f32 = f32(0.2188); |
| |
| var<workgroup> vw37: atomic<i32>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct VertexOutput9 { |
| @builtin(position) f19: vec4f, |
| } |
| |
| struct T4 { |
| @align(16) @size(240) f0: array<i32>, |
| } |
| |
| var<private> vp19: vec4h = vec4h(9994.5, 9824.0, 25315.5, 7674.2); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<private> vp20 = modf(vec2f(0.04567, 0.04646)); |
| |
| var<workgroup> vw36: atomic<i32>; |
| |
| var<private> vp15 = modf(vec4f(0.6631, 0.07320, 0.1166, 0.05934)); |
| |
| struct T0 { |
| f0: array<vec2h, 1>, |
| @size(64) f1: array<array<array<f32, 1>, 1>, 4>, |
| } |
| |
| /* zero global variables used */ |
| fn fn0(a0: array<f16, 1>) -> VertexOutput9 { |
| var out: VertexOutput9; |
| var vf143: vec2h = log(vec2h(vp15.whole.br)); |
| let vf144: f16 = vp19[u32(vp17.whole.g)]; |
| var vf145: mat4x4f = (mat2x4f(unconst_f32(0.01120), unconst_f32(0.1329), unconst_f32(0.2637), unconst_f32(0.3498), unconst_f32(0.07828), unconst_f32(0.7408), unconst_f32(0.00368), unconst_f32(-0.1511)) * mat4x2f(unconst_f32(0.04141), unconst_f32(0.04092), unconst_f32(0.3621), unconst_f32(0.02429), unconst_f32(0.02086), unconst_f32(0.1503), unconst_f32(0.1071), unconst_f32(0.09822))); |
| { |
| let ptr93: ptr<private, vec4f> = &vp15.whole; |
| out = VertexOutput9(vec4f(abs(vec3i(unconst_i32(499), unconst_i32(105), unconst_i32(202))).zxxx)); |
| let vf146: vec4i = unpack4xI8(unconst_u32(1)); |
| let ptr94: ptr<private, vec4f> = &vp15.whole; |
| vp20.fract -= vec2f(f32(any(bool(refract(vec3h(unconst_f16(2467.6), unconst_f16(-27865.3), unconst_f16(4058.8)), vec3h(unconst_f16(595.6), unconst_f16(6669.0), unconst_f16(-3017.4)), unconst_f16(-3841.1))[2])))); |
| } |
| let ptr95: ptr<private, vec4f> = &vp15.fract; |
| let vf147: f16 = a0[0]; |
| var vf148: vec3h = reflect(vec3h(unconst_f16(14387.7), unconst_f16(15564.8), unconst_f16(11845.6)), vec3h(unconst_f16(38246.3), unconst_f16(7716.6), unconst_f16(5406.2))); |
| let vf149: f32 = log(unconst_f32(0.1501)); |
| let vf150: f16 = vf148[unconst_u32(460)]; |
| let vf151: f16 = a0[0]; |
| var vf152: f16 = a0[u32(vf143[unconst_u32(17)])]; |
| let ptr96 = &vp20; |
| vf152 = vf151; |
| let vf153: f16 = a0[unconst_u32(142)]; |
| let ptr97: ptr<private, vec2f> = &(*ptr96).fract; |
| return out; |
| } |
| |
| @group(0) @binding(251) var<storage, read> buffer132: array<array<array<array<array<f16, 6>, 1>, 16>, 26>>; |
| |
| struct T5 { |
| f0: array<atomic<i32>, 28>, |
| @align(16) @size(128) f1: array<u32>, |
| } |
| |
| struct T3 { |
| @align(16) @size(4992) f0: array<T0>, |
| } |
| |
| struct T6 { |
| @align(32) @size(4992) f0: array<atomic<i32>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex9() -> VertexOutput9 { |
| var out: VertexOutput9; |
| let vf154: vec2f = acosh(vec2f(ldexp(vec2h(unconst_f16(16477.6), unconst_f16(7260.9)), vec2i(unconst_i32(132), unconst_i32(57))))); |
| switch vec4i(vp19).g { |
| default { |
| var vf155 = fn0(array<f16, 1>(vp17.whole[1])); |
| if bool(max(vec4h(unconst_f16(1154.1), unconst_f16(3430.5), unconst_f16(21520.5), unconst_f16(25113.2)), vec4h(unconst_f16(11986.8), unconst_f16(2941.3), unconst_f16(5789.5), unconst_f16(3799.8))).w) { |
| vp17 = modf(vec3h(vp20.fract.yxy)); |
| break; |
| } |
| fn0(array<f16, 1>(f16((vec2i(unconst_i32(496), unconst_i32(111)) << vec2u(unconst_u32(43), unconst_u32(187)))[0]))); |
| var vf156 = fn0(array<f16, 1>(vp17.fract.r)); |
| return out; |
| } |
| } |
| while any(unconst_bool(false)) { |
| let ptr98: ptr<private, vec4f> = &vp15.fract; |
| loop { |
| fn0(array<f16, 1>(f16(pack2x16float(vec2f(unconst_f32(0.07150), unconst_f32(0.2524)))))); |
| fn0(array<f16, 1>(f16(round(vec4f(unconst_f32(0.1531), unconst_f32(0.2288), unconst_f32(0.02356), unconst_f32(0.2668)))[2]))); |
| out.f19 = sign(vec4f(unconst_f32(0.1448), unconst_f32(0.1373), unconst_f32(0.1768), unconst_f32(-0.03307))); |
| break; |
| } |
| vp19 += vec4h(f16((*ptr98)[unconst_u32(40)])); |
| return out; |
| } |
| vp17.fract = (mat2x4h(unconst_f16(17075.6), unconst_f16(43823.9), unconst_f16(16040.1), unconst_f16(1182.3), unconst_f16(9265.7), unconst_f16(3308.6), unconst_f16(16854.8), unconst_f16(16917.1)) * mat2x2h(ldexp(vec2h(unconst_f16(881.6), unconst_f16(1621.1)), vec2i(unconst_i32(29), unconst_i32(79))), ldexp(vec2h(unconst_f16(881.6), unconst_f16(1621.1)), vec2i(unconst_i32(29), unconst_i32(79)))))[unconst_i32(0)].bgb; |
| out.f19 += vec4f(step(vec3h(unconst_f16(26547.1), unconst_f16(2235.2), unconst_f16(848.3)), vec3h(unconst_f16(1964.1), unconst_f16(7345.2), unconst_f16(5317.4))).rrbb); |
| var vf157 = fn0(array<f16, 1>(fma(vec4h(unconst_f16(3501.7), unconst_f16(8175.3), unconst_f16(1532.0), unconst_f16(3967.5)), vec4h(f16(any(unconst_bool(true)))), vec4h(f16(vf154[unconst_u32(28)])))[3])); |
| out.f19 *= vp15.fract; |
| var vf158: f32 = exp(unconst_f32(0.2043)); |
| var vf159 = fn0(array<f16, 1>(f16(vf158))); |
| var vf160: f32 = fma(unconst_f32(0.2283), unconst_f32(0.1861), unconst_f32(0.02126)); |
| return out; |
| } |
| |
| /* used global variables: buffer132 */ |
| @fragment |
| fn fragment10() -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| discard; |
| fn0(array<f16, 1>(buffer132[arrayLength(&buffer132)][unconst_u32(512)][15][0][unconst_u32(506)])); |
| let ptr99: ptr<storage, f16, read> = &buffer132[unconst_u32(150)][25][15][0][5]; |
| vp20.whole = vec2f(f32((*&buffer132)[unconst_u32(8)][unconst_u32(313)][15][unconst_u32(356)][5])); |
| let ptr100: ptr<storage, f16, read> = &(*&buffer132)[unconst_u32(296)][25][15][unconst_u32(40)][unconst_u32(88)]; |
| fn0(array<f16, 1>(buffer132[unconst_u32(298)][25][15][unconst_u32(56)][5])); |
| vp19 = vec4h((*&buffer132)[u32(buffer132[arrayLength(&buffer132)][25][15][0][5])][unconst_u32(170)][15][unconst_u32(6)][5]); |
| vp20 = modf(vec2f(f32((*&buffer132)[unconst_u32(66)][25][15][0][unconst_u32(347)]))); |
| return out; |
| _ = buffer132; |
| } |
| |
| /* used global variables: buffer131 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute7() { |
| var vf161: vec3f = quantizeToF16(vec3f(unconst_f32(0.07264), unconst_f32(0.2039), unconst_f32(0.2562))); |
| let ptr101: ptr<private, vec4h> = &vp19; |
| let ptr102: ptr<private, vec3h> = &vp17.fract; |
| let ptr103: ptr<storage, atomic<i32>, read_write> = &(*&buffer131).f0[unconst_u32(99)]; |
| var vf162: f16 = (*ptr102)[unconst_u32(98)]; |
| let vf163: vec2f = refract(vec2f(unconst_f32(0.00614), unconst_f32(0.03646)), vec2f(unconst_f32(0.09023), unconst_f32(0.03355)), unconst_f32(0.1913)); |
| vf162 = vw33[unconst_u32(41)][u32(atomicLoad(&(*ptr103)))]; |
| let ptr104: ptr<workgroup, mat3x3h> = &(*&vw33); |
| atomicMin(&vw35, unconst_i32(212)); |
| let ptr105: ptr<workgroup, mat3x3h> = &(*ptr104); |
| _ = buffer131; |
| } |
| |
| /* used global variables: buffer131 */ |
| @compute @workgroup_size(3, 1, 1) |
| fn compute8(@builtin(local_invocation_id) a0: vec3u) { |
| var vf164: vec3u = (vec3u(unconst_u32(399), unconst_u32(88), unconst_u32(144)) >> vec3u(unconst_u32(31), unconst_u32(74), unconst_u32(172))); |
| var vf165: u32 = pack4x8unorm(vec4f(unconst_f32(0.7443), unconst_f32(0.06586), unconst_f32(0.1281), unconst_f32(0.1164))); |
| for (var it7=reverseBits(vec4u(unconst_u32(339), unconst_u32(58), unconst_u32(327), unconst_u32(67))).r; it7<u32(vw33[unconst_i32(2)][0]); it7++) { |
| vp19 += vec4h(vw33[unconst_u32(282)][unconst_u32(73)]); |
| vp17 = modf(vec3h(pow(vec3f(unconst_f32(0.00993), unconst_f32(0.2691), unconst_f32(-0.03373)), vec3f(unconst_f32(0.2376), unconst_f32(0.08088), unconst_f32(0.1755))))); |
| atomicMax(&vw35, unconst_i32(-870)); |
| vp18 = bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.07509), unconst_f32(0.06800)))); |
| let ptr106: ptr<workgroup, atomic<i32>> = &(*&vw37); |
| let ptr107: ptr<storage, array<atomic<i32>>, read_write> = &buffer131.f0; |
| break; |
| _ = buffer131; |
| } |
| for (var it8=u32(atomicLoad(&(*&vw37))); it8<bitcast<u32>(saturate(vec3f(unconst_f32(0.04516), unconst_f32(0.01825), unconst_f32(0.04176)))[1]); it8++) { |
| let ptr108 = &vp15; |
| vw33 = mat3x3h(f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155))), f16(atomicExchange(&(*&buffer131).f0[unconst_u32(257)], unconst_i32(155)))); |
| let ptr109: ptr<workgroup, atomic<i32>> = &(*&vw36); |
| let ptr110: ptr<workgroup, atomic<i32>> = &(*ptr109); |
| let ptr111: ptr<storage, atomic<i32>, read_write> = &(*&buffer131).f0[unconst_i32(-108)]; |
| loop { |
| vp16 = bool(vw33[unconst_u32(149)][2]); |
| break; |
| } |
| _ = buffer131; |
| } |
| let ptr112: ptr<private, bool> = &vp16; |
| _ = buffer131; |
| }`, |
| }); |
| let veryExplicitBindGroupLayout29 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 1, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }}, |
| {binding: 5, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let buffer133 = device1.createBuffer({size: 190, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let texture224 = device1.createTexture({ |
| size: [1, 80, 1], |
| mipLevelCount: 2, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder137.setBindGroup(2, bindGroup112, [256]); |
| } catch {} |
| try { |
| computePassEncoder202.setBindGroup(2, bindGroup98, new Uint32Array(1933), 1_065, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer111, 'uint16', 108, 149); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer115, 3044, new Int16Array(4521), 70, 252); |
| } catch {} |
| let textureView213 = texture148.createView({dimension: '2d-array'}); |
| let computePassEncoder216 = commandEncoder206.beginComputePass({}); |
| try { |
| computePassEncoder190.setBindGroup(0, bindGroup53, [0]); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup108, [0]); |
| } catch {} |
| try { |
| renderPassEncoder3.setScissorRect(0, 43, 0, 114); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer31); |
| } catch {} |
| let pipeline31 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| multisample: {mask: 0xb6ff622}, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment5', |
| constants: {35_410: 1}, |
| targets: [{format: 'rg16uint'}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 588, |
| stepMode: 'instance', |
| attributes: [{format: 'float16x2', offset: 164, shaderLocation: 8}], |
| }, |
| ], |
| }, |
| }); |
| let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout7]}); |
| let sampler132 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.10, |
| maxAnisotropy: 4, |
| }); |
| try { |
| renderPassEncoder3.drawIndexed(8, 1, 2, -1_256_606_487, 5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 140, new DataView(new ArrayBuffer(3761)), 1192, 416); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 21} |
| */ |
| { |
| source: imageData20, |
| origin: { x: 16, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 5, y: 18, z: 12}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup116 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [{binding: 174, resource: {buffer: buffer71, offset: 512, size: 128}}], |
| }); |
| let buffer134 = device0.createBuffer({size: 15202, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder132.setBindGroup(0, bindGroup7, [768]); |
| } catch {} |
| try { |
| computePassEncoder133.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(17, 0, 537_290_437); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer62, 900); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer128, 'uint32', 760, 37); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture168, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 6}, |
| aspect: 'all', |
| }, new Uint8Array(9_168).fill(160), /* required buffer size: 9_168 */ |
| {offset: 38, bytesPerRow: 166, rowsPerImage: 11}, {width: 41, height: 0, depthOrArrayLayers: 6}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer135 = device0.createBuffer({ |
| size: 5224, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(111, 91, 50_697_982, 289_763_447); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer14, 1_708); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer106, 'uint32', 32, 23); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer35, 552, 3_215); |
| } catch {} |
| try { |
| commandEncoder138.copyBufferToBuffer(buffer41, 2336, buffer121, 72, 44); |
| } catch {} |
| let bindGroup117 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 495, resource: {buffer: buffer68, offset: 768}}, |
| {binding: 28, resource: textureView42}, |
| {binding: 34, resource: textureView99}, |
| {binding: 14, resource: sampler47}, |
| ], |
| }); |
| let buffer136 = device0.createBuffer({ |
| size: 3985, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView214 = texture98.createView({dimension: 'cube', mipLevelCount: 2, baseArrayLayer: 2}); |
| let computePassEncoder217 = commandEncoder138.beginComputePass({}); |
| try { |
| computePassEncoder96.setBindGroup(1, bindGroup40, [1024]); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup70, new Uint32Array(3057), 419, 1); |
| } catch {} |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(172, 2, 2_746_432_684); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(3, 2, 36, -1_740_870_207, 1); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer47, 5_464); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline16); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let commandEncoder210 = device0.createCommandEncoder({}); |
| let computePassEncoder218 = commandEncoder210.beginComputePass({}); |
| let renderPassEncoder21 = commandEncoder14.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView139, |
| clearValue: { r: -246.3, g: -96.73, b: -945.0, a: -462.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder73.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(1, 0, 3, 348_214_028, 2); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer25, 1_028); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer89, 0, 601); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer21]); |
| } catch {} |
| let veryExplicitBindGroupLayout30 = device1.createBindGroupLayout({entries: [{binding: 284, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }}]}); |
| let renderBundleEncoder20 = device1.createRenderBundleEncoder({colorFormats: ['rg32uint']}); |
| let renderBundle20 = renderBundleEncoder20.finish({}); |
| try { |
| computePassEncoder170.setBindGroup(0, bindGroup98, new Uint32Array(182), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer115, 'uint32', 2_212, 1_770); |
| } catch {} |
| let promise33 = device1.queue.onSubmittedWorkDone(); |
| let commandEncoder211 = device0.createCommandEncoder({}); |
| let renderPassEncoder22 = commandEncoder211.beginRenderPass({colorAttachments: [{view: textureView130, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder215.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup23, new Uint32Array(3578), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(209, 0, 2_026_937_334, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(10, 6, 7, 378_577_079); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer5, 124); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(5, buffer80, 472); |
| } catch {} |
| let arrayBuffer17 = buffer1.getMappedRange(2496, 0); |
| try { |
| commandEncoder168.copyBufferToTexture({ |
| /* bytesInLastRow: 388 widthInBlocks: 97 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 424 */ |
| offset: 424, |
| rowsPerImage: 307, |
| buffer: buffer29, |
| }, { |
| texture: texture146, |
| mipLevel: 1, |
| origin: {x: 164, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 97, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| await gc(); |
| let bindGroup118 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [{binding: 209, resource: textureView58}, {binding: 79, resource: textureView56}], |
| }); |
| let commandEncoder212 = device0.createCommandEncoder({}); |
| let sampler133 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 50.54, compare: 'less'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder120); computePassEncoder120.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup118, new Uint32Array(1540), 237, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer22, 888); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer35, 2_844); |
| } catch {} |
| try { |
| commandEncoder212.copyTextureToBuffer({ |
| texture: texture190, |
| mipLevel: 1, |
| origin: {x: 0, y: 17, z: 2}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1904 */ |
| offset: 1904, |
| bytesPerRow: 3584, |
| buffer: buffer73, |
| }, {width: 0, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await promise33; |
| } catch {} |
| let renderPassEncoder23 = commandEncoder212.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView139, |
| clearValue: { r: 49.10, g: 125.3, b: -385.6, a: -358.5, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler134 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 87.46}); |
| try { |
| computePassEncoder85.setBindGroup(3, bindGroup81); |
| } catch {} |
| try { |
| computePassEncoder216.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderPassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer72, 232); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(0, buffer34, 200); |
| } catch {} |
| try { |
| commandEncoder168.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 68 */ |
| offset: 68, |
| bytesPerRow: 8704, |
| buffer: buffer84, |
| }, { |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 1, y: 192, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 165, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder69.clearBuffer(buffer126, 964); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer80, 36, new Float32Array(2827), 1240, 92); |
| } catch {} |
| let commandEncoder213 = device1.createCommandEncoder({}); |
| let computePassEncoder219 = commandEncoder213.beginComputePass({}); |
| try { |
| await buffer96.mapAsync(GPUMapMode.WRITE, 0, 300); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(24).fill(188), /* required buffer size: 24 */ |
| {offset: 24, bytesPerRow: 75}, {width: 4, height: 320, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout18 = pipeline6.getBindGroupLayout(0); |
| let texture225 = device0.createTexture({size: [2, 1095, 1], format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView215 = texture97.createView({aspect: 'stencil-only'}); |
| let computePassEncoder220 = commandEncoder168.beginComputePass({}); |
| try { |
| renderPassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(3.0003451632123803, 1098.9345917450783, 0.7317160481558183, 471.1832746227924, 0.09376546005682618, 0.36759323055172943); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer44, 'uint32', 1_464, 6_681); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline28); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToBuffer(buffer41, 2104, buffer18, 3768, 120); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToTexture({ |
| /* bytesInLastRow: 260 widthInBlocks: 130 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 224 */ |
| offset: 224, |
| buffer: buffer59, |
| }, { |
| texture: texture124, |
| mipLevel: 1, |
| origin: {x: 41, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 130, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder83.copyTextureToBuffer({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 0, y: 77, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 950 */ |
| offset: 950, |
| bytesPerRow: 12032, |
| rowsPerImage: 100, |
| buffer: buffer54, |
| }, {width: 0, height: 16, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder69.clearBuffer(buffer33, 2624, 4276); |
| } catch {} |
| try { |
| computePassEncoder172.popDebugGroup(); |
| } catch {} |
| let commandEncoder214 = device0.createCommandEncoder({}); |
| let computePassEncoder221 = commandEncoder83.beginComputePass({}); |
| let arrayBuffer18 = buffer32.getMappedRange(24, 4); |
| try { |
| commandEncoder69.copyBufferToBuffer(buffer67, 1052, buffer9, 1696, 104); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 274 */ |
| offset: 274, |
| bytesPerRow: 5120, |
| buffer: buffer121, |
| }, { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 0, y: 158, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 134, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder36.insertDebugMarker('\u0818'); |
| } catch {} |
| let pipeline32 = await device0.createComputePipelineAsync({layout: pipelineLayout7, compute: {module: shaderModule2, entryPoint: 'compute2', constants: {}}}); |
| let imageData23 = new ImageData(12, 60); |
| let commandBuffer22 = commandEncoder69.finish({}); |
| let texture226 = device0.createTexture({size: {width: 1}, dimension: '1d', format: 'rg16uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let texture227 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView216 = texture42.createView({}); |
| let sampler135 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup52, new Uint32Array(1195), 428, 1); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(60, 120, 52_763_773, 337_141_140); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(49, 34, 191, 139_844_984, 608_547_705); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer49, 'uint16', 2_030, 480); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(6, buffer66, 88, 9_838); |
| } catch {} |
| try { |
| commandEncoder214.copyBufferToBuffer(buffer38, 220, buffer17, 836, 136); |
| } catch {} |
| let commandEncoder215 = device0.createCommandEncoder({}); |
| let texture228 = device0.createTexture({ |
| size: [1, 136, 1], |
| mipLevelCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup91, [0]); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame6.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(); |
| videoFrame22.close(); |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0() ]; |
| log('promises created'); |
| let results = await Promise.allSettled(promises); |
| for (let result of results) { |
| if (result.status === 'rejected') { throw result.reason; } |
| } |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| debug('Pass') |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
| |
