| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script> |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| const log = globalThis.$vm?.print ?? 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 = [ |
| `data:video/mp4;base64,AAAAFGZ0eXBxdCAgAAAAAHF0ICAAAAAId2lkZQAAAU1tZGF0AAAAHgYFGkdWStxcTEM/lO/FETzRQ6gB/8zM/wIABr//gAAAAFgluCAfgCzoj//8eCyKIA6ld6GiWNMysFDzQ6B0eKZOHCoYx/qDmAAASsGxgpD9GOyUuV2X2TbC82uSHQykVbKdIl1ez0Y4oBd1ThIi3aGA3KgFgNuFlMbMAAAAOSHhCF8BCiSBNYLgmz0HwAQXT4VwcYONVAlh4AfvmC+QzGhM3au6JfZPbp1BU7asdTUtdCSp7qYAgAAAADEBqIGJv/ScwzAAAAMAGlAAAEzAU4oa5OqOZ7A19laXo9z4wmN5AIMC+Bng8wq4gYWAAAAAIyHiEEv/ALCyQLLgyyaz3DSqW6o67AfmaWoR6vWvjVy2XAE0AAAAKgGow4//9JdwIAAAAwABBwAAAwLwAnIyzNPkAA24JECMAwYUMKmFVDGQYAAAA7xtb292AAAAbG12aGQAAAAA4ueqKuLnqioAAAJYAAALuAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAADSHRyYWsAAABcdGtoZAAAAA/i56oq4ueqKgAAAAEAAAAAAAALuAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAABAAAAAQAAAAAAAER0YXB0AAAAFGNsZWYAAAAAAQAAAAEAAAAAAAAUcHJvZgAAAAABAAAAAQAAAAAAABRlbm9mAAAAAAEAAAABAAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAAALuAAAAAAAAQAAAAACfG1kaWEAAAAgbWRoZAAAAADi56oq4ueqKgAAAlgAAAu4VcQAAAAAADFoZGxyAAAAAG1obHJ2aWRlYXBwbAAAAAAAAAAAEENvcmUgTWVkaWEgVmlkZW8AAAIjbWluZgAAABR2bWhkAAAAAQBAgACAAIAAAAAAOGhkbHIAAAAAZGhscmFsaXNhcHBsAAAAAAAAAAAXQ29yZSBNZWRpYSBEYXRhIEhhbmRsZXIAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMYWxpcwAAAAEAAAGrc3RibAAAAKZzdHNkAAAAAAAAAAEAAACWYXZjMQAAAAAAAAABAAAAAAAAAAAAAAIAAAACAAEAAQAASAAAAEgAAAAAAAAAAQVILjI2NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAACphdmNDAWQADf/hAA8nZAANrFYoEAhpqEiAMBABAAQo7jyw/fj4AAAAABJjb2xybmNsYwAJABAABgAAAAAAAAAYc3R0cwAAAAAAAAABAAAABQAAAlgAAAA4Y3R0cwAAAAAAAAAFAAAAAQAAAAAAAAABAAACWAAAAAH///2oAAAAAQAAAlgAAAAB///9qAAAACBjc2xnAAAAAAAAAlj///2oAAACWAAAAAAAAAu4AAAAFHN0c3MAAAAAAAAAAQAAAAEAAAARc2R0cAAAAAAgEBgQGAAAABxzdHNjAAAAAAAAAAEAAAABAAAAAQAAAAEAAAAoc3RzegAAAAAAAAAAAAAABQAAAH4AAAA9AAAANQAAACcAAAAuAAAAJHN0Y28AAAAAAAAABQAAACQAAACiAAAA3wAAARQAAAE7`, |
| `data:video/mp4;base64,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`, |
| ]; |
| |
| /** |
| * @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; |
| } |
| |
| onload = async () => { |
| try { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| ], |
| requiredLimits: { |
| maxBindingsPerBindGroup: 1000, |
| maxUniformBufferBindingSize: 117361015, |
| maxStorageBufferBindingSize: 147038495, |
| maxSamplersPerShaderStage: 16, |
| }, |
| }); |
| let bindGroupLayout0 = device0.createBindGroupLayout({ |
| label: '\u{1f61e}\u{1f920}\u09b1\ue4c7\u8243\u13cb\u{1fa16}\u0349', |
| entries: [ |
| { |
| binding: 80, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 462}); |
| let texture0 = device0.createTexture({ |
| label: '\u0672\u06a6\u{1f81c}\u0035\uf8c3', |
| size: [329, 24, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView0 = texture0.createView({dimension: '2d-array'}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass({label: '\u7092\u3c8e\u03f6'}); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let texture1 = device0.createTexture({ |
| label: '\u8800\u09c2\u{1fa93}\u97dd\u4f2d\u0da5\u0ecf\u4c34', |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder1 = commandEncoder1.beginComputePass({}); |
| let video0 = await videoWithData(112); |
| let buffer0 = device0.createBuffer({size: 1143, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView1 = texture1.createView({label: '\u9bc2\u{1ff34}', dimension: '2d'}); |
| let bindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 19, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 589, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 168, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| ], |
| }); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 0.7760, |
| compare: 'greater', |
| maxAnisotropy: 6, |
| }); |
| let texture2 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'astc-12x12-unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler1 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 13.71, |
| lodMaxClamp: 57.19, |
| }); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView1}]}); |
| let texture3 = device0.createTexture({ |
| size: {width: 329, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView2 = texture1.createView({dimension: '2d-array'}); |
| let sampler2 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 99.30, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(1546), 15, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 192, new DataView(new ArrayBuffer(2997)), 52, 40); |
| } catch {} |
| let imageData0 = new ImageData(4, 104); |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer1 = device0.createBuffer({ |
| label: '\u7385\u0ae5\uf395\u{1fb4e}\u322a\u03f9', |
| size: 47178, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX, |
| }); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let textureView3 = texture3.createView({mipLevelCount: 1}); |
| let computePassEncoder2 = commandEncoder2.beginComputePass({}); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(2760), 340, 0); |
| } catch {} |
| await gc(); |
| let canvas0 = document.createElement('canvas'); |
| let texture4 = device0.createTexture({ |
| size: [150, 24, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler3 = device0.createSampler({ |
| label: '\u0dfd\uc052\u1ca2\u0d71\u03be\u0983\u8c6e\u407a\uaaac', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 27.87, |
| lodMaxClamp: 67.06, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(2007), 120, 0); |
| } catch {} |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 443}); |
| let textureView4 = texture0.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(494), 29, 0); |
| } catch {} |
| try { |
| commandEncoder3.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 17, y: 10, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 992 */ |
| offset: 992, |
| bytesPerRow: 512, |
| rowsPerImage: 101, |
| buffer: buffer0, |
| }, {width: 3, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.label = '\u0974\u{1f777}\u{1fd80}\u3e83\u6830\ucaaf'; |
| } catch {} |
| let buffer2 = device0.createBuffer({size: 8974, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let texture5 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 1}, |
| format: 'astc-6x6-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView5 = texture1.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let sampler4 = device0.createSampler({ |
| label: '\u{1f930}\u{1fafb}\uef36', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 18.60, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(1903), 12, 0); |
| } catch {} |
| try { |
| commandEncoder4.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 12, y: 4, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 40 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1144 */ |
| offset: 1144, |
| buffer: buffer1, |
| }, {width: 5, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 4020, new Int16Array(4300), 16, 740); |
| } catch {} |
| await gc(); |
| let bindGroupLayout2 = device0.createBindGroupLayout({ |
| label: '\u0731\u0f0d\u7848\u486a\ued5e\ufb08\u03ad\u0306', |
| entries: [ |
| { |
| binding: 28, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let computePassEncoder3 = commandEncoder3.beginComputePass({}); |
| try { |
| commandEncoder4.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 212 */ |
| offset: 212, |
| bytesPerRow: 768, |
| rowsPerImage: 141, |
| buffer: buffer2, |
| }, { |
| texture: texture3, |
| mipLevel: 1, |
| origin: {x: 11, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer3 = device0.createBuffer({size: 13222, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandBuffer0 = commandEncoder5.finish({}); |
| let computePassEncoder4 = commandEncoder4.beginComputePass({label: '\u0827\u05a5\u{1fa33}\u2d0a\u{1ff01}\uc9d6\ued26\ua7f8'}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| await buffer2.mapAsync(GPUMapMode.WRITE, 0, 160); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| let buffer4 = device0.createBuffer({ |
| size: 50885, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 118}); |
| let textureView6 = texture5.createView({}); |
| let computePassEncoder5 = commandEncoder6.beginComputePass(); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| let arrayBuffer0 = buffer2.getMappedRange(0, 8); |
| document.body.prepend(video0); |
| let buffer5 = device0.createBuffer({size: 2139, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let texture6 = device0.createTexture({ |
| size: [2, 2, 12], |
| dimension: '2d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView7 = texture1.createView({label: '\u2376\u0385\u6902', format: 'r32float'}); |
| let sampler5 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 44.30, |
| lodMaxClamp: 74.79, |
| maxAnisotropy: 14, |
| }); |
| try { |
| commandEncoder7.resolveQuerySet(querySet0, 6, 91, buffer3, 768); |
| } catch {} |
| video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; }); |
| let computePassEncoder6 = commandEncoder7.beginComputePass({}); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0, bindGroupLayout0, bindGroupLayout0]}); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 4, new Int16Array(11611), 359, 564); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let sampler6 = device0.createSampler({ |
| label: '\u005e\u1515\u476a\u0798\u042a\u{1fa23}', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 55.86, |
| lodMaxClamp: 94.32, |
| compare: 'greater', |
| }); |
| try { |
| commandEncoder8.copyBufferToBuffer(buffer1, 4876, buffer5, 368, 16); |
| } catch {} |
| try { |
| commandEncoder8.clearBuffer(buffer5, 36, 536); |
| } catch {} |
| try { |
| window.someLabel = sampler4.label; |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 73 max align: 1 */ |
| struct T0 { |
| @align(1) @size(73) f0: array<vec2i>, |
| } |
| @group(0) @binding(80) var st0: texture_storage_2d<r32float, read_write>; |
| @group(1) @binding(80) var st1: texture_storage_3d<r32uint, read_write>; |
| @group(2) @binding(80) var st2: texture_storage_2d<r32float, read_write>; |
| struct VertexOutput0 { |
| @location(9) f0: vec2u, |
| @location(11) f1: f16, |
| @location(12) f2: vec2i, |
| @location(15) @interpolate(flat, center) f3: vec2i, |
| @location(1) @interpolate(flat) f4: u32, |
| @location(6) @interpolate(linear, centroid) f5: vec2h, |
| @builtin(position) f6: vec4f, |
| @location(14) f7: vec2f |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput0 { |
| var out: VertexOutput0; |
| out.f2 = vec2i(34, 35); |
| return out; |
| } |
| struct FragmentOutput0 { |
| @location(7) @interpolate(flat) f0: vec2f, |
| @location(0) @interpolate(perspective, centroid) f1: vec4f |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| return out; |
| } |
| |
| @compute @workgroup_size(3, 1, 1) |
| fn compute0() { |
| if bool(textureLoad(st0, vec2i())[0]) { |
| return; |
| } |
| if bool(textureLoad(st1, vec3i())[1]) { |
| textureStore(st0, vec2i(), vec4f(0.1217, 0.06508, 0.3978, 0.01886)); |
| } |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let texture7 = device0.createTexture({ |
| label: '\u{1f716}\u196f\u8442\u03f7\u06e2\ua30b\u7327\u35bd\u0689\u2b9f', |
| size: [2880], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler7 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 47.40, |
| lodMaxClamp: 75.56, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(368), 268, 0); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 724 */ |
| offset: 724, |
| buffer: buffer1, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 32, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 128, new DataView(new ArrayBuffer(20480)), 2765, 672); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout2]}); |
| let buffer6 = device0.createBuffer({ |
| size: 8652, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let querySet3 = device0.createQuerySet({ |
| label: '\ub49b\u{1ff8b}\u1bcf\u08af\u098f\u{1fcf9}\u{1ff40}\ube74\u0c9a', |
| type: 'occlusion', |
| count: 977, |
| }); |
| let texture8 = device0.createTexture({ |
| size: [600, 96, 179], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView8 = texture1.createView({}); |
| let computePassEncoder7 = commandEncoder8.beginComputePass({label: '\u585c\ufd61\u27fc\u{1f7d9}\ub77c\ue97d\u3bbf\u3307\u0f13\ud3b9'}); |
| let sampler8 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 72.98, |
| lodMaxClamp: 76.70, |
| }); |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| let bindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 90, |
| visibility: 0, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup1 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView8}]}); |
| let texture9 = device0.createTexture({ |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder8 = commandEncoder9.beginComputePass({label: '\u3f6c\u358d\u{1f6fe}'}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let texture10 = device0.createTexture({ |
| size: {width: 600, height: 96, depthOrArrayLayers: 1}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture11 = device0.createTexture({ |
| size: {width: 75, height: 12, depthOrArrayLayers: 5}, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView9 = texture10.createView({label: '\u0c89\u0f0e', dimension: '2d-array'}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(1294), 39, 0); |
| } catch {} |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let texture12 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder9 = commandEncoder10.beginComputePass({}); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup1); |
| } catch {} |
| let promise0 = shaderModule0.getCompilationInfo(); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 54 max align: 2 */ |
| struct T0 { |
| @align(2) @size(54) f0: array<array<f32, 1>>, |
| } |
| /* target size: 54 max align: 2 */ |
| struct T1 { |
| @align(2) @size(8) f0: atomic<i32>, |
| @align(2) f1: array<array<atomic<u32>, 1>, 1>, |
| @align(2) f2: atomic<u32>, |
| @align(1) @size(8) f3: array<atomic<u32>, 1>, |
| @align(2) @size(30) f4: vec3i, |
| } |
| @group(0) @binding(28) var<storage, read_write> buffer7: array<T1, 1>; |
| struct S0 { |
| @builtin(vertex_index) f0: u32, |
| @builtin(instance_index) f1: u32, |
| @location(7) @interpolate(linear, center) f2: f32, |
| @location(9) f3: i32, |
| @location(15) f4: f16, |
| @location(6) @interpolate(flat, center) f5: vec4u, |
| @location(0) @interpolate(flat) f6: vec4i, |
| @location(13) f7: vec3h, |
| @location(12) @interpolate(flat, centroid) f8: vec2f, |
| @location(10) f9: vec4f, |
| @location(4) f10: vec2h, |
| @location(1) @interpolate(flat) f11: i32, |
| @location(8) f12: vec2f |
| } |
| struct VertexOutput1 { |
| @builtin(position) f8: vec4f |
| } |
| |
| @vertex |
| fn vertex0(@location(14) a0: vec3i, a1: S0, @location(2) a2: vec3i) -> VertexOutput1 { |
| var out: VertexOutput1; |
| _ = a1.f12; |
| _ = a1.f2; |
| _ = a1.f5; |
| return out; |
| } |
| struct FragmentOutput1 { |
| @location(0) @interpolate(flat, centroid) f0: vec4f |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| _ = buffer7[0].f3; |
| _ = atomicExchange(&buffer7[0].f0, 352); |
| _ = buffer7[0].f1[0][0]; |
| _ = atomicExchange(&buffer7[0].f2, 160); |
| _ = buffer7[0].f0; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute0() { |
| } |
| |
| @compute @workgroup_size(2, 2, 1) |
| fn compute1(@builtin(global_invocation_id) a0: vec3u, @builtin(local_invocation_index) a1: u32) { |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let textureView10 = texture12.createView({baseArrayLayer: 0}); |
| let texture13 = device0.createTexture({size: {width: 720}, dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup1, new Uint32Array(1804), 57, 0); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 28, resource: {buffer: buffer6, offset: 1536}}]}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup0, []); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| document.body.prepend(video0); |
| let commandEncoder11 = device0.createCommandEncoder({label: '\ufdfd\u6907\uc8e0\u056d\ua638\u039c'}); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 590}); |
| try { |
| commandEncoder11.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 36, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 136 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 912 */ |
| offset: 912, |
| bytesPerRow: 1280, |
| buffer: buffer6, |
| }, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 90, resource: textureView10}]}); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let texture14 = device0.createTexture({ |
| size: [600, 96, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder10 = commandEncoder11.beginComputePass({}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup3, new Uint32Array(4211), 566, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 652, new BigUint64Array(6307), 1021, 28); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 15, y: 8, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(481).fill(119), /* required buffer size: 481 */ |
| {offset: 481, bytesPerRow: 1565}, {width: 91, height: 25, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer1 = commandEncoder12.finish({}); |
| let sampler9 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 90.51, |
| lodMaxClamp: 93.21, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup1, new Uint32Array(1516), 47, 0); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let imageData1 = new ImageData(4, 20); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let computePassEncoder11 = commandEncoder13.beginComputePass({label: '\ua3cf\u0909\u{1f848}\u5401\u09b6\u579e\u{1ff77}\u{1fcd7}\u{1fa91}\u6ad7\ubf01'}); |
| let commandEncoder14 = device0.createCommandEncoder(); |
| let texture15 = device0.createTexture({ |
| size: [2, 2, 297], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let sampler10 = device0.createSampler({ |
| label: '\uabfb\uc00a\u077a', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 59.19, |
| lodMaxClamp: 95.79, |
| compare: 'never', |
| }); |
| try { |
| await promise0; |
| } catch {} |
| let texture16 = device0.createTexture({ |
| size: {width: 659, height: 48, depthOrArrayLayers: 1}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture17 = device0.createTexture({ |
| size: [300], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView11 = texture12.createView({}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup0, new Uint32Array(642), 5, 0); |
| } catch {} |
| let imageData2 = new ImageData(8, 12); |
| let bindGroup4 = device0.createBindGroup({ |
| label: '\u{1fa02}\u{1fb49}\u01d8', |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer4, offset: 9216, size: 3404}}], |
| }); |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let texture18 = device0.createTexture({ |
| size: [600], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture19 = gpuCanvasContext0.getCurrentTexture(); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let textureView12 = texture15.createView({format: 'rgb10a2unorm', mipLevelCount: 1}); |
| let computePassEncoder12 = commandEncoder15.beginComputePass({}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup0); |
| } catch {} |
| await gc(); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let textureView13 = texture0.createView({}); |
| let computePassEncoder13 = commandEncoder16.beginComputePass(); |
| let renderPassEncoder0 = commandEncoder14.beginRenderPass({colorAttachments: [{view: textureView12, depthSlice: 11, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setViewport(1.6305095164307506, 0.9131893714078101, 0.0284089878732458, 0.7734580693568436, 0.784004561495834, 0.9654182324852681); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer6, 'uint16', 2_442, 175); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let computePassEncoder14 = commandEncoder17.beginComputePass({}); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(638); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer3, 2_300, 170); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| document.body.append(video0); |
| let commandEncoder18 = device0.createCommandEncoder({label: '\u0117\u24b0\u{1f62b}\ub72f\u{1fc91}\u8667'}); |
| let texture20 = device0.createTexture({ |
| size: [82, 6, 1], |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture21 = device0.createTexture({ |
| size: [2880, 4, 1], |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView14 = texture12.createView({dimension: '2d-array'}); |
| let computePassEncoder15 = commandEncoder18.beginComputePass({label: '\u0649\u01ea\u{1f8f4}\u{1fa5f}\u5ecf\udce0\u0835\u0dc6'}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(3456), 810, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer4, 'uint16', 6_150, 10_213); |
| } catch {} |
| try { |
| querySet3.destroy(); |
| } catch {} |
| canvas0.width = 1103; |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'bt709'} }); |
| let buffer8 = device0.createBuffer({ |
| size: 3436, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture22 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 12}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup3, new Uint32Array(2952), 2_808, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline0 = device0.createRenderPipeline({ |
| label: '\u0d4d\ueeb0', |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: {module: shaderModule0, buffers: []}, |
| primitive: {cullMode: 'front'}, |
| }); |
| let texture23 = device0.createTexture({ |
| size: {width: 150}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 3, y: 27 }, |
| flipY: true, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 588, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 8 max align: 8 */ |
| struct T0 { |
| @align(1) @size(8) f0: array<atomic<u32>>, |
| } |
| /* target size: 8 max align: 8 */ |
| struct T1 { |
| @size(8) f0: atomic<i32>, |
| } |
| @group(2) @binding(80) var st5: texture_storage_1d<r32uint, read_write>; |
| @group(1) @binding(80) var st4: texture_storage_1d<r32uint, read_write>; |
| @group(0) @binding(80) var st3: texture_storage_1d<r32float, read_write>; |
| struct VertexOutput2 { |
| @location(10) f9: i32, |
| @location(4) @interpolate(flat, center) f10: vec4h, |
| @builtin(position) f11: vec4f, |
| @location(13) f12: vec4i, |
| @location(15) @interpolate(flat, centroid) f13: vec4i |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput2 { |
| var out: VertexOutput2; |
| return out; |
| } |
| |
| @fragment |
| fn fragment0() -> @location(200) @interpolate(flat) vec4f { |
| var out: vec4f; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute0() { |
| _ = textureLoad(st5, 0); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let sampler11 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| lodMinClamp: 29.01, |
| lodMaxClamp: 58.30, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(2927), 647, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer4, 0, 2_996); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 102, y: 72 }, |
| flipY: false, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 419, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 81, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer9 = device0.createBuffer({ |
| size: 17821, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup3, new Uint32Array(175), 42, 0); |
| } catch {} |
| try { |
| commandEncoder20.clearBuffer(buffer5, 60, 140); |
| } catch {} |
| let buffer10 = device0.createBuffer({ |
| label: '\u0b38\u{1fca3}\u{1f97f}\u77eb\u{1f771}\u{1f67e}\ub506\u0cd8\u{1f7b6}', |
| size: 6864, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| commandEncoder19.copyTextureToTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 12, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder20.clearBuffer(buffer0, 132, 32); |
| } catch {} |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'logSqrt'} }); |
| let bindGroup5 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer6, offset: 512, size: 2456}}], |
| }); |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let textureView15 = texture12.createView({dimension: '2d-array', aspect: 'all'}); |
| let textureView16 = texture12.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder16 = commandEncoder21.beginComputePass({}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToBuffer(buffer1, 12100, buffer6, 140, 3888); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 208, new Float32Array(14106), 589, 12); |
| } catch {} |
| try { |
| adapter0.label = '\u{1f96e}\u{1fddf}\u088e\u00ac\uc050\u08b2\u0e08\uff9f\ua1e4\u{1fab0}'; |
| } catch {} |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let texture24 = device0.createTexture({ |
| size: [150, 24, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder17 = commandEncoder22.beginComputePass(); |
| let renderPassEncoder1 = commandEncoder19.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 5, |
| clearValue: { r: 558.8, g: -733.7, b: -669.7, a: -724.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup5, new Uint32Array(2844), 404, 0); |
| } catch {} |
| try { |
| commandEncoder20.copyTextureToBuffer({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 157, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2388 widthInBlocks: 597 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1156 */ |
| offset: 1156, |
| bytesPerRow: 2816, |
| buffer: buffer9, |
| }, {width: 597, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let texture25 = device0.createTexture({ |
| size: {width: 360}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView17 = texture24.createView({ |
| label: '\uc34d\u0349\u0d72\u0967\u{1f9d1}\u7543\u{1f8dc}\u{1f6f0}', |
| format: 'rgb10a2unorm', |
| baseMipLevel: 0, |
| mipLevelCount: 1, |
| }); |
| let computePassEncoder18 = commandEncoder20.beginComputePass({}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer8, 'uint16', 622, 228); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 3328, new DataView(new ArrayBuffer(8680)), 3203, 436); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 1, |
| origin: {x: 26, y: 7, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(377).fill(18), /* required buffer size: 377 */ |
| {offset: 377, bytesPerRow: 34}, {width: 5, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let texture26 = device0.createTexture({ |
| size: {width: 2}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView18 = texture25.createView({baseMipLevel: 0}); |
| let sampler12 = device0.createSampler({ |
| label: '\u{1f6e9}\u{1fbcc}\u0304\ua7f0\ued46\u9f95', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 24.91, |
| lodMaxClamp: 96.45, |
| maxAnisotropy: 18, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, undefined, 447_500_782, 167_214_681); |
| } catch {} |
| let arrayBuffer1 = buffer2.getMappedRange(8, 20); |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 69, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 3, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 0, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 271, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let imageData3 = new ImageData(24, 84); |
| let texture27 = device0.createTexture({ |
| size: {width: 164}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture28 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder19 = commandEncoder23.beginComputePass({}); |
| let sampler13 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 10.07, |
| lodMaxClamp: 76.94, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup5, new Uint32Array(368), 72, 0); |
| } catch {} |
| document.body.append(canvas0); |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'film', transfer: 'smpte240m'} }); |
| let texture29 = device0.createTexture({ |
| size: [720, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView19 = texture25.createView({label: '\u{1fa34}\u949a\u967c\u{1ffa9}', format: 'rgb10a2unorm'}); |
| let sampler14 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 35.56, |
| lodMaxClamp: 42.10, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(1930), 399, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline1 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {}}}); |
| let bindGroup6 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 589, resource: {buffer: buffer9, offset: 4608, size: 674}}, |
| {binding: 19, resource: textureView6}, |
| {binding: 168, resource: sampler10}, |
| ], |
| }); |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let computePassEncoder20 = commandEncoder24.beginComputePass({label: '\u90e3\u0883\u0ec8\ue152\u{1f688}\u{1fefb}\uee53'}); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup1, new Uint32Array(1844), 1_202, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer4, 'uint32', 14_848, 18_621); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(32_785).fill(132), /* required buffer size: 32_785 */ |
| {offset: 214, bytesPerRow: 77, rowsPerImage: 9}, {width: 0, height: 0, depthOrArrayLayers: 48}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 148} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 28 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 14}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| let commandBuffer2 = commandEncoder25.finish({}); |
| let texture30 = device0.createTexture({ |
| label: '\u{1fe93}\u09cc\u9b66\u6467\u17c8', |
| size: [2], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView20 = texture9.createView({label: '\u0f40\u0657\u0d2c\u7ed1\u0b09\u{1f809}', aspect: 'all', baseMipLevel: 0}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup3, new Uint32Array(124), 34, 0); |
| } catch {} |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder(); |
| let texture31 = device0.createTexture({ |
| size: [150, 24, 15], |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder2 = commandEncoder26.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 178, |
| clearValue: { r: 322.8, g: 760.9, b: -617.3, a: 47.30, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 632523012, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup1); |
| } catch {} |
| let promise1 = shaderModule1.getCompilationInfo(); |
| document.body.prepend(video0); |
| let buffer11 = device0.createBuffer({ |
| label: '\u6154\u{1f656}\u{1fa1f}\uc525\u3c12\u{1f79f}\ufcf7\u0025\u5220\ud50c', |
| size: 9510, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let computePassEncoder21 = commandEncoder27.beginComputePass(); |
| let renderPassEncoder3 = commandEncoder22.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 76, |
| clearValue: { r: 681.7, g: 773.9, b: -179.4, a: -570.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 168733421, |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(1137), 129, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer1, 'uint32', 1_756, 62); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt470m', transfer: 'log'} }); |
| let bindGroup7 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView8}]}); |
| let buffer12 = device0.createBuffer({size: 6468, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup0, new Uint32Array(237), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer9, 0); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| try { |
| computePassEncoder15.insertDebugMarker('\u{1ffdb}'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(62).fill(118), /* required buffer size: 62 */ |
| {offset: 62}, {width: 112, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup8 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer4, offset: 15104, size: 11628}}], |
| }); |
| let texture32 = device0.createTexture({ |
| size: {width: 1440}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler15 = device0.createSampler({ |
| label: '\u12d7\ue456\u420b', |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 89.12, |
| lodMaxClamp: 92.96, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup3, new Uint32Array(211), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup5, new Uint32Array(663), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 4_042, 393); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'astc-12x12-unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['stencil8'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| sampler15.label = '\u0ddd\u0548'; |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView8}]}); |
| let texture33 = device0.createTexture({ |
| label: '\u7801\u3b11\u09b7\u{1ffc0}\u0d37\uf695\uf1fd\u0ebf', |
| size: [164, 12, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView21 = texture30.createView({baseArrayLayer: 0}); |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 9.008, |
| lodMaxClamp: 41.74, |
| }); |
| try { |
| computePassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer1, 'uint32', 3_208, 2_926); |
| } catch {} |
| let buffer13 = device0.createBuffer({ |
| size: 23857, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder6.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(2847), 942, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let computePassEncoder22 = commandEncoder28.beginComputePass({}); |
| try { |
| computePassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer1, 'uint16', 7_976, 6_198); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, buffer4, 0, 2_663); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 1629, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 168, resource: sampler10}, |
| {binding: 589, resource: {buffer: buffer9, offset: 256, size: 1296}}, |
| {binding: 19, resource: textureView17}, |
| ], |
| }); |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let texture34 = device0.createTexture({ |
| label: '\u04eb\u2852\uaa20\u{1fe18}\u5dad\u98d2\u1013\ufe76', |
| size: [659, 48, 1], |
| mipLevelCount: 8, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder23 = commandEncoder29.beginComputePass({}); |
| try { |
| computePassEncoder13.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup0, new Uint32Array(2257), 402, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(31, 24, 341_702_840, 1_899_720_157); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 456); |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 589, resource: {buffer: buffer9, offset: 3328, size: 2052}}, |
| {binding: 19, resource: textureView3}, |
| {binding: 168, resource: sampler6}, |
| ], |
| }); |
| let commandEncoder30 = device0.createCommandEncoder({label: '\ud259\uc3ce\u72bf\u00f8\u3284\u009a\u{1fbc9}\u{1f681}'}); |
| let textureView22 = texture11.createView({dimension: '3d', format: 'rgb10a2unorm'}); |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer8, 920); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 5208, new BigUint64Array(707), 184, 72); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 16 max align: 16 */ |
| struct T0 { |
| @align(2) @size(16) f0: array<i32, 1>, |
| } |
| /* target size: 69 max align: 1 */ |
| struct T1 { |
| @align(1) @size(12) f0: vec2h, |
| @align(1) @size(54) f1: mat3x4h, |
| @align(1) @size(3) f2: array<array<array<f16, 1>, 1>>, |
| } |
| /* target size: 7 max align: 1 */ |
| struct T2 { |
| @align(1) @size(7) f0: atomic<i32>, |
| } |
| /* target size: 8 max align: 8 */ |
| struct T3 { |
| f0: array<array<array<array<vec2u, 1>, 1>, 1>, 1>, |
| } |
| /* target size: 34 max align: 2 */ |
| struct T4 { |
| @align(2) @size(16) f0: array<array<vec2u, 1>, 1>, |
| @align(2) f1: i32, |
| @align(2) @size(10) f2: atomic<u32>, |
| @align(1) f3: array<atomic<i32>, 1>, |
| } |
| /* target size: 8 max align: 8 */ |
| struct T5 { |
| @size(8) f0: array<atomic<u32>>, |
| } |
| @group(0) @binding(80) var st6: texture_storage_3d<r32float, read_write>; |
| @group(1) @binding(80) var st7: texture_storage_2d_array<r32uint, read_write>; |
| @group(2) @binding(80) var st8: texture_storage_2d<r32float, read_write>; |
| struct VertexOutput3 { |
| @builtin(position) f14: vec4f |
| } |
| |
| @vertex |
| fn vertex0(@location(0) a0: vec3u, @location(3) a1: vec3f, @location(8) a2: i32) -> VertexOutput3 { |
| var out: VertexOutput3; |
| if bool(a0[0]) { |
| var v: vec4f; |
| } |
| out.f14 = vec4f(bitcast<f32>(a2)); |
| return out; |
| } |
| struct FragmentOutput2 { |
| @location(5) @interpolate(linear) f0: vec2f, |
| @location(0) @interpolate(perspective) f1: vec4f |
| } |
| |
| @fragment |
| fn fragment0(@location(14) @interpolate(flat) a0: vec2f) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| return out; |
| } |
| struct FragmentOutput3 { |
| @location(0) f0: vec4f |
| } |
| |
| @fragment |
| fn fragment1(@builtin(front_facing) a0: bool, @builtin(position) a1: vec4f) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| _ = a1; |
| if a0 { |
| discard; |
| } |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute0(@builtin(workgroup_id) a0: vec3u) { |
| _ = textureLoad(st7, vec2i(), 0); |
| if bool(a0[0]) { |
| textureStore(st8, vec2i(), vec4f(0.2846, 0.04950, 0.06842, 0.00779)); |
| } |
| if bool(a0[0]) { |
| textureStore(st7, vec2i(), 0, vec4u(14, 151, 529, 1)); |
| } |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let computePassEncoder24 = commandEncoder30.beginComputePass({}); |
| try { |
| computePassEncoder9.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 168); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, buffer9); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let texture35 = device0.createTexture({ |
| size: {width: 720}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup3, new Uint32Array(1206), 179, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup1, new Uint32Array(1091), 33, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 96); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer4, 0, 3_751); |
| } catch {} |
| try { |
| window.someLabel = device0.queue.label; |
| } catch {} |
| try { |
| buffer13.label = '\u02ee\u029b\ub734\u{1fe05}\u4406'; |
| } catch {} |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let texture36 = device0.createTexture({ |
| size: [150, 24, 1], |
| mipLevelCount: 3, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder4 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 4, |
| clearValue: { r: -181.3, g: 961.3, b: 859.0, a: 684.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 326418651, |
| }); |
| try { |
| computePassEncoder24.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 1_264); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 6}, |
| aspect: 'all', |
| }, new Uint8Array(40).fill(30), /* required buffer size: 40 */ |
| {offset: 40}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer14 = device0.createBuffer({size: 1922, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView23 = texture21.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder0.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(78, 107, 1, 118_834_383, 551_243_548); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 1_964); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer1, 'uint16', 1_012, 12_157); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 316, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture37 = device0.createTexture({ |
| label: '\u0463\u{1f7bd}\ua6aa\u04f3\ude6c\ud981\u7c21\u{1fc01}\u25f8\u1a78', |
| size: [720], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(58); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(15, 195, 5, 22_617_354, 795_210_407); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer1, 'uint32', 22_088, 1_074); |
| } catch {} |
| let promise2 = shaderModule1.getCompilationInfo(); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| await promise1; |
| } catch {} |
| document.body.prepend(video0); |
| await gc(); |
| let textureView24 = texture22.createView({dimension: 'cube-array', aspect: 'all', arrayLayerCount: 6}); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 99.16, |
| lodMaxClamp: 99.94, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup7, new Uint32Array(631), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer15 = device0.createBuffer({size: 6181, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder32 = device0.createCommandEncoder(); |
| let texture38 = device0.createTexture({ |
| label: '\u35f7\u{1f63a}\u0e78\u9d00\u0fd7\u06b5\u3c9d\u0454', |
| size: {width: 82, height: 6, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(3, 24, 12, 88_758_966, 1_450_636_263); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer1, 'uint32', 1_392, 753); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| let buffer16 = device0.createBuffer({ |
| size: 19488, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| mappedAtCreation: true, |
| }); |
| let computePassEncoder25 = commandEncoder32.beginComputePass({}); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup6, new Uint32Array(2817), 1_597, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(3, 6, 11, 579_733_117, 148_330_600); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer15, 88); |
| } catch {} |
| try { |
| window.someLabel = device0.queue.label; |
| } catch {} |
| let texture39 = device0.createTexture({ |
| label: '\uc2aa\u1aa6\u0f2f\u24a8', |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgb10a2unorm'], |
| }); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup1, new Uint32Array(1006), 224, 0); |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(227, 7, 267_657_663, 199_267_606); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer16, 5_720); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 4_586, 5_492); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 168, resource: sampler2}, |
| {binding: 589, resource: {buffer: buffer9, offset: 3328, size: 2819}}, |
| {binding: 19, resource: textureView6}, |
| ], |
| }); |
| let externalTexture0 = device0.importExternalTexture({source: video0}); |
| try { |
| computePassEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(5, 56, 2, 150_630_924, 2_026_963_154); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer15, 208); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer16, 5_340); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| canvas0.width = 3097; |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let renderPassEncoder5 = commandEncoder33.beginRenderPass({ |
| label: '\u0733\u600f\u{1f944}\u08bb\u1cf5\u0079\u{1f824}', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 149, |
| clearValue: { r: 89.80, g: 898.7, b: -877.1, a: 308.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 192); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer13, 'uint32', 18_592, 1_672); |
| } catch {} |
| let buffer17 = device0.createBuffer({size: 9102, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder34 = device0.createCommandEncoder({label: '\ud960\u0e7b\u14d2\u06f0\u0b3a\u1d4f\u0c4f\u1ad8\u6e81\u{1f977}'}); |
| let textureView25 = texture22.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let computePassEncoder26 = commandEncoder34.beginComputePass(); |
| try { |
| computePassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer16, 1_100); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(5, buffer4, 0, 3_100); |
| } catch {} |
| let texture40 = device0.createTexture({ |
| label: '\u{1f81b}\ud3b8\u42c2\u47db\ue353\u02d6\u{1f9bd}', |
| size: {width: 164}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView26 = texture11.createView({}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer13, 'uint32', 4_628, 6_102); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer9, offset: 9984, size: 880}}], |
| }); |
| let buffer18 = device0.createBuffer({size: 3223, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder35 = device0.createCommandEncoder({label: '\u038c\u396d\u04fa\ub3fe\uf84c\u58ce\u{1fb19}'}); |
| let texture41 = device0.createTexture({ |
| size: [720, 1, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(258, 775, 145_716_232, 327_334_689); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(13, 43, 58, -2_081_212_586, 972_796_893); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer16, 1_220); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer13, 'uint16', 5_078, 5_408); |
| } catch {} |
| try { |
| commandEncoder35.resolveQuerySet(querySet3, 240, 23, buffer17, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 26}, |
| aspect: 'all', |
| }, new Uint8Array(47_323).fill(199), /* required buffer size: 47_323 */ |
| {offset: 283, bytesPerRow: 28, rowsPerImage: 42}, {width: 0, height: 0, depthOrArrayLayers: 41}); |
| } catch {} |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 27.41, |
| lodMaxClamp: 29.87, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup6, new Uint32Array(319), 53, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(144, 35, 233, -1_480_472_327, 1_026_031_649); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer16, 2_144); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer13, 0, 3_120); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 48, new Float32Array(2788), 35, 676); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(canvas0); |
| let bindGroup14 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 90, resource: textureView10}]}); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let textureView27 = texture34.createView({baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer16, 264); }; |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer16, 2_140); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer6, 'uint16', 238, 8_214); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer9); |
| } catch {} |
| let renderPassEncoder6 = commandEncoder35.beginRenderPass({ |
| label: '\u{1fd25}\u1f33\uf518\u41ea\u{1f78a}\u0752\u309f\u{1fb24}', |
| colorAttachments: [{ |
| view: textureView23, |
| clearValue: { r: 571.3, g: 36.69, b: -33.53, a: 527.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup13, new Uint32Array(1133), 363, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer8, 1_144); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| let bindGroupLayout4 = device0.createBindGroupLayout({ |
| label: '\ue56c\ua299\u03f9\u135d\u9f39\u{1f714}\u0674\u9304\u4213\ua261\u9b8a', |
| entries: [ |
| { |
| binding: 49, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 234, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 374, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView28 = texture28.createView({format: 'rgba8unorm'}); |
| let texture42 = device0.createTexture({ |
| label: '\u6d02\u4bf6\uba40\u0cee\uf918\u{1f83c}\u4e9e\u548a\u{1fccf}\u067e\u1686', |
| size: {width: 659, height: 48, depthOrArrayLayers: 37}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder27 = commandEncoder36.beginComputePass(); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({ |
| label: '\u{1f88d}\u{1fa58}\u08f3\u0345\u0ee9\u3f86', |
| colorFormats: ['rgb10a2unorm'], |
| depthReadOnly: true, |
| }); |
| let sampler19 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 92.24, |
| lodMaxClamp: 98.99, |
| compare: 'always', |
| maxAnisotropy: 12, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup10, new Uint32Array(1177), 40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(339), 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 25_044, 811); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| let pipeline2 = device0.createComputePipeline({ |
| label: '\u199d\u2e21\u0190\u3694', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule2, constants: {}}, |
| }); |
| let buffer19 = device0.createBuffer({size: 10636, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder37 = device0.createCommandEncoder(); |
| let texture43 = device0.createTexture({ |
| label: '\ud144\u{1fabb}\u{1f88e}\ua1ae\u0974\u0f8b', |
| size: {width: 150}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView29 = texture17.createView({aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1}); |
| let computePassEncoder28 = commandEncoder37.beginComputePass(); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({label: '\u0f8e\u0a3f\u82a1', colorFormats: ['rgb10a2unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup1, new Uint32Array(3043), 95, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer15, 688); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 4_164, 3_414); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, undefined, 0, 229_882_183); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint32', 5_944, 2_056); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(5, buffer6, 116, 906); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| let buffer20 = device0.createBuffer({ |
| size: 16185, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup3, []); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(1534), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(131, 5, 476_514_138, 303_446_594); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(2_082, 180, 462, 13_364_254, 513_196_636); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer8, 456); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer16, 1_068); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| let img0 = await imageWithData(29, 57, '#10101010', '#20202020'); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'film', transfer: 'gamma22curve'} }); |
| let textureView30 = texture17.createView({}); |
| let sampler20 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'nearest', lodMinClamp: 6.060, compare: 'never'}); |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(342, 270, 451, 508_118_393, 61_731_920); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer4, 'uint32', 1_480, 5_591); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer6, 'uint16', 964, 665); |
| } catch {} |
| let imageData4 = new ImageData(72, 8); |
| let commandEncoder38 = device0.createCommandEncoder(); |
| let texture44 = device0.createTexture({ |
| size: {width: 2880}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture45 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundle0 = renderBundleEncoder1.finish({}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup4, new Uint32Array(583), 178, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(52, 171, 250_771_945, 1_263_166_679); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer19, 864); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 368); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer20, 'uint16', 236, 1_954); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(0, buffer20, 3_420); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| let pipeline3 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {}}}); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let imageData5 = new ImageData(4, 140); |
| let commandEncoder39 = device0.createCommandEncoder(); |
| let computePassEncoder29 = commandEncoder38.beginComputePass({}); |
| let renderPassEncoder7 = commandEncoder39.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 261, |
| clearValue: { r: -52.00, g: 787.0, b: -916.2, a: 987.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup10, new Uint32Array(2313), 173, 0); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup12, new Uint32Array(721), 238, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(227, 140, 146_011_771, 43_013_263); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer6, 'uint32', 368, 300); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer13, 'uint32', 2_948, 2_847); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder0.insertDebugMarker('\u00d7'); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let renderPassEncoder8 = commandEncoder40.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 185, |
| clearValue: { r: -305.4, g: -128.9, b: 240.6, a: 60.96, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer16, 1_056); }; |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup0, new Uint32Array(2495), 531, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(44, 315, 1_845_744_276, 2_823_629_560); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(392, 104, 92, -1_867_002_578, 4_294_967_191); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(3, bindGroup13, new Uint32Array(2946), 537, 0); |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView31 = texture41.createView({ |
| label: '\u0b58\u{1fdfa}\ue0b6\u8cd8\u110c\u{1fcda}\u2876', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| arrayLayerCount: 1, |
| }); |
| let texture46 = device0.createTexture({ |
| size: [720, 1, 1], |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder30 = commandEncoder41.beginComputePass({}); |
| try { |
| computePassEncoder28.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup7, new Uint32Array(2752), 251, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(107, 41, 490_150_115, 670_287_902); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(30, 655, 15, 12_369_125, 158_469_322); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer8, 1_828); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer20, 'uint32', 556, 205); |
| } catch {} |
| await gc(); |
| let promise3 = adapter0.requestAdapterInfo(); |
| let bindGroup15 = device0.createBindGroup({ |
| label: '\u0ebc\u0326\u01e8\u0450\ud2a7\u19e8\u{1fd08}\u35b3', |
| layout: bindGroupLayout0, |
| entries: [{binding: 80, resource: textureView1}], |
| }); |
| let textureView32 = texture22.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup5, []); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(135, 315, 144_449_662, 269_657_123); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer8, 52); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer13, 'uint32', 3_004, 9_587); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer3, 4_608, 298); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(286), 66, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let texture47 = device0.createTexture({ |
| label: '\u08cc\u02f0\u0889\u1174\u{1fa98}\u0cbd\uaf81', |
| size: [82, 6, 174], |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView33 = texture35.createView({}); |
| let renderPassEncoder9 = commandEncoder42.beginRenderPass({ |
| label: '\u03d4\uea5d\u956d\u1e88\u7525\u{1f9e1}\u004c', |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 47, |
| clearValue: { r: 180.7, g: 135.9, b: -486.5, a: -197.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let renderBundle1 = renderBundleEncoder0.finish({}); |
| try { |
| computePassEncoder16.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 1_212); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer9); |
| } catch {} |
| let pipeline4 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| vertex: {module: shaderModule2, buffers: []}, |
| primitive: {topology: 'point-list'}, |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup0, new Uint32Array(154), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(245, 132, 224, 721_320_471, 1_080_799_187); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 2_700); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer8, 84); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer13, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(video0); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let texture48 = device0.createTexture({ |
| label: '\u9504\u3370\u9f7e\u050f', |
| size: {width: 300, height: 48, depthOrArrayLayers: 3}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView34 = texture47.createView({}); |
| let renderPassEncoder10 = commandEncoder43.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView23, |
| clearValue: { r: -329.0, g: -48.45, b: 109.2, a: -548.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(236, 583, 483_993_933, 1_068_177_966); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 2_492); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| let imageData6 = new ImageData(40, 28); |
| let buffer21 = device0.createBuffer({ |
| label: '\u0220\u27d4\u1fd6\u778a\ua191\ude7e\u78fd\u0c55\u48eb\uc8b9\u06dd', |
| size: 5052, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture49 = device0.createTexture({size: {width: 360}, dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup6, new Uint32Array(83), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(63, 24, 1_697_290_801, 444_491_255); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(2, 55, 5, 258_248_369, 2_523_648_374); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer8, 300); |
| } catch {} |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 495}); |
| let texture50 = device0.createTexture({ |
| size: [164, 12, 1], |
| mipLevelCount: 3, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder31 = commandEncoder44.beginComputePass({}); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 44.19, |
| lodMaxClamp: 63.53, |
| }); |
| try { |
| computePassEncoder5.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(37, 77, 222_734_659, 43_418_353); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer15, 472); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 45 max align: 1 */ |
| struct T0 { |
| @align(1) @size(45) f0: array<array<array<array<vec4h, 1>, 1>, 1>>, |
| } |
| /* target size: 27 max align: 1 */ |
| struct T1 { |
| @align(1) @size(16) f0: vec3u, |
| @align(1) f1: vec2h, |
| @align(1) @size(7) f2: atomic<u32>, |
| } |
| @group(2) @binding(80) var st11: texture_storage_2d<r32float, read_write>; |
| @group(0) @binding(80) var st9: texture_storage_2d<r32float, read_write>; |
| @group(1) @binding(80) var st10: texture_storage_2d_array<r32float, read_write>; |
| struct VertexOutput4 { |
| @location(1) @interpolate(perspective, center) f15: vec3h, |
| @builtin(position) f16: vec4f, |
| @location(3) f17: vec3f, |
| @location(5) f18: vec2u, |
| @location(15) @interpolate(flat) f19: vec4u |
| } |
| |
| @vertex |
| fn vertex0(@location(8) a0: vec3u, @location(11) @interpolate(flat) a1: vec2h, @location(0) a2: u32, @location(10) a3: vec2f) -> VertexOutput4 { |
| var out: VertexOutput4; |
| if bool(a3[0]) { |
| out.f16 = a3.rggg; |
| } |
| return out; |
| } |
| struct S1 { |
| @location(3) f0: vec3f, |
| @location(15) @interpolate(flat) f1: vec4u |
| } |
| struct FragmentOutput4 { |
| @location(4) f0: vec3f, |
| @builtin(sample_mask) f1: u32, |
| @location(5) f2: vec3u, |
| @location(0) f3: vec4f |
| } |
| |
| @fragment |
| fn fragment0(a0: S1) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| _ = a0.f1; |
| if bool(a0.f0[2]) { |
| out.f3 = bitcast<vec4f>(a0.f1); |
| } |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute0() { |
| _ = textureLoad(st10, vec2i(), 0); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer22 = device0.createBuffer({size: 11538, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let renderPassEncoder11 = commandEncoder45.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: -643.8, g: -174.1, b: -982.8, a: 659.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 42, y: 24, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(62_463).fill(13), /* required buffer size: 62_463 */ |
| {offset: 43, bytesPerRow: 44, rowsPerImage: 101}, {width: 7, height: 5, depthOrArrayLayers: 15}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| label: '\u{1f7b2}\u{1f8d0}\u0a0e\u5d93\u0f70\u0574\u5ebb', |
| layout: bindGroupLayout0, |
| entries: [{binding: 80, resource: textureView13}], |
| }); |
| let buffer23 = device0.createBuffer({ |
| size: 4048, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder46 = device0.createCommandEncoder({label: '\uc549\u07ee\ud0fd\u53ac\uacdc\uf218\u0e11'}); |
| let textureView35 = texture28.createView({aspect: 'all'}); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup7, new Uint32Array(67), 24, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup10, new Uint32Array(294), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer15, 12); |
| } catch {} |
| try { |
| commandEncoder46.copyBufferToBuffer(buffer22, 260, buffer5, 36, 248); |
| } catch {} |
| document.body.append(img0); |
| let buffer24 = device0.createBuffer({size: 32108, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture51 = device0.createTexture({ |
| size: [164, 12, 1], |
| dimension: '2d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgb10a2unorm'], |
| }); |
| let computePassEncoder32 = commandEncoder46.beginComputePass({}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup12, new Uint32Array(849), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer21, 248); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer16, 1_924); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let imageData7 = new ImageData(8, 48); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let texture52 = device0.createTexture({ |
| size: [164, 12, 658], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer19, 1_264); |
| } catch {} |
| let commandEncoder47 = device0.createCommandEncoder({label: '\u0339\u2d54'}); |
| let renderPassEncoder12 = commandEncoder47.beginRenderPass({colorAttachments: [{view: textureView27, loadOp: 'load', storeOp: 'discard'}]}); |
| let sampler22 = device0.createSampler({ |
| label: '\u65c8\u7156\u0e79\u6bb9\u50aa\u074d\u{1fa2e}\u0db7\u937c\u{1f9c0}\u05db', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 83.59, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup3, new Uint32Array(1982), 102, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer16, 100); }; |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer15, 608); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer1, 'uint16', 540, 6_053); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let pipeline5 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment1', |
| targets: [{ |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 28, |
| attributes: [ |
| {format: 'float16x4', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 8}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list'}, |
| }); |
| document.body.prepend(canvas0); |
| canvas0.width = 221; |
| let texture53 = device0.createTexture({ |
| size: {width: 720, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView36 = texture11.createView({label: '\u0e37\u{1f70f}\u8d7c\u{1fd40}\u0a47\uadb8\u{1fdc3}\u5af2\u0c47\u1af5'}); |
| try { |
| computePassEncoder25.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(77, 298, 1_282_952_361, 683_390_702); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(8, 152, 29, -1_868_169_047, 62_137_227); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer20); |
| } catch {} |
| video0.width = 10; |
| let bindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 598, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView37 = texture34.createView({mipLevelCount: 2, baseArrayLayer: 0}); |
| let sampler23 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 5.515, |
| lodMaxClamp: 85.05, |
| compare: 'never', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder29.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder11.setBlendConstant({ r: 32.34, g: 284.0, b: 943.7, a: 395.1, }); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(96, 16, 186_703_376, 74_532_142); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(268, 173, 147, 594_929_444, 218_302_481); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer8, 'uint16', 558, 27); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(4, buffer23, 96); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView7}]}); |
| let texture54 = device0.createTexture({ |
| label: '\u9122\u57c9\u{1ff67}\u0fb6\u0673\u39ee\ubf45\ud9d7', |
| size: [300], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2unorm'], |
| }); |
| let textureView38 = texture44.createView({format: 'rgb10a2unorm', mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler24 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 39.74, |
| lodMaxClamp: 45.72, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer8, 76); }; |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup17, new Uint32Array(416), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(498, 149, 937_904_752, 1_112_523_649); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(9, 144, 4, -1_519_719_491, 506_151_392); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer15, 1_224); |
| } catch {} |
| let bindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 64, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView39 = texture32.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup4, new Uint32Array(686), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(538, 3, 1_541_751_723, 3_354_328); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer8, 160); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 3, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(162).fill(97), /* required buffer size: 162 */ |
| {offset: 162, bytesPerRow: 232}, {width: 14, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| window.someLabel = commandEncoder38.label; |
| } catch {} |
| let buffer25 = device0.createBuffer({ |
| size: 2776, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup7, new Uint32Array(90), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup10, new Uint32Array(520), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 1_828); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer8, 'uint32', 1_616, 621); |
| } catch {} |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup9, new Uint32Array(33), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle1, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer13, 'uint16', 4_420, 34); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let pipelineLayout5 = device0.createPipelineLayout({label: '\u8b29\u0f18\u8cef\u{1fe22}\u002c', bindGroupLayouts: [bindGroupLayout4]}); |
| let commandEncoder48 = device0.createCommandEncoder(); |
| let texture55 = device0.createTexture({ |
| label: '\ucd44\u{1fc30}\u0bb8\ue3c4\u41a4\u069f\u3e15\ud701\u066a\uc469\ubc31', |
| size: {width: 2880, height: 4, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup13, new Uint32Array(4056), 998, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(202, 13, 193, -1_945_969_339, 1_024_607_584); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture56 = device0.createTexture({ |
| label: '\u7c37\u{1f98c}\ue7b8\u{1f87f}\u6311\u0b8f\u{1fa1b}\ud5fc\uf44c', |
| size: [164, 12, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView40 = texture20.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer16, 960); }; |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer16, 568); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToTexture({ |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4388 */ |
| offset: 4388, |
| buffer: buffer10, |
| }, { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 55, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 468, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer26 = device0.createBuffer({ |
| size: 8620, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| mappedAtCreation: true, |
| }); |
| let renderPassEncoder13 = commandEncoder48.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 46, |
| clearValue: { r: 758.7, g: -590.3, b: 570.6, a: 30.41, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], stencilReadOnly: true}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer16, 4_216); }; |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer21, 1_824); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup16, new Uint32Array(1010), 30, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer4, 'uint32', 6_632, 5_669); |
| } catch {} |
| try { |
| computePassEncoder2.insertDebugMarker('\u0380'); |
| } catch {} |
| try { |
| renderBundleEncoder2.insertDebugMarker('\ubefe'); |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView8}]}); |
| let commandEncoder49 = device0.createCommandEncoder(); |
| let computePassEncoder33 = commandEncoder49.beginComputePass({}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup14, []); |
| } catch {} |
| try { |
| computePassEncoder27.setBindGroup(3, bindGroup4, new Uint32Array(1987), 229, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(13, 60, 15, 39_281_229, 1_134_108_566); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer3, 0, 1_957); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 72, new Int16Array(299), 52, 36); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| try { |
| adapter0.label = '\u6e95\u022f\u07c6\u{1fcdc}\u{1fa59}'; |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 90, resource: textureView20}]}); |
| let texture57 = device0.createTexture({ |
| size: {width: 2880, height: 4, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView41 = texture48.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder33.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup1, new Uint32Array(730), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(347, 74, 939_131_962, 1_156_945_140); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer19, 3_148); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer1, 'uint32', 6_712, 4_553); |
| } catch {} |
| try { |
| texture26.destroy(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let videoFrame5 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| let commandEncoder50 = device0.createCommandEncoder(); |
| let texture58 = device0.createTexture({ |
| size: [2880, 4, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder14 = commandEncoder50.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView23, |
| clearValue: { r: -254.0, g: 336.9, b: -837.8, a: 529.5, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet5, |
| }); |
| let renderBundle2 = renderBundleEncoder2.finish({}); |
| let externalTexture1 = device0.importExternalTexture({source: video0}); |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup11, new Uint32Array(2401), 511, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle1, renderBundle0, renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(39, 125, 478_104_639, 482_732_055); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 4_412); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer25, 0); |
| } catch {} |
| await gc(); |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| enable f16; |
| /* target size: 12 max align: 4 */ |
| struct T0 { |
| f0: atomic<i32>, |
| @size(8) f1: atomic<i32>, |
| } |
| /* target size: 119 max align: 1 */ |
| struct T1 { |
| @align(1) @size(119) f0: array<mat2x2h>, |
| } |
| /* target size: 17 max align: 1 */ |
| struct T2 { |
| @align(1) @size(17) f0: array<array<f16, 1>>, |
| } |
| /* target size: 8 max align: 8 */ |
| struct T3 { |
| @size(8) f0: array<vec2h, 1>, |
| } |
| /* target size: 8 max align: 8 */ |
| struct T4 { |
| f0: T3, |
| } |
| @group(0) @binding(49) var st12: texture_storage_2d_array<rg32sint, write>; |
| @group(0) @binding(234) var sam0: sampler; |
| @group(0) @binding(374) var st13: texture_storage_2d<rgba8snorm, read>; |
| @group(0) @binding(15) var tex0: texture_depth_cube_array; |
| struct S2 { |
| @builtin(sample_mask) f0: u32, |
| @location(1) @interpolate(perspective) f1: vec3h, |
| @builtin(front_facing) f2: bool, |
| @location(3) f3: vec3f, |
| @location(5) f4: vec2u |
| } |
| struct FragmentOutput5 { |
| @location(0) f0: vec4f, |
| @builtin(sample_mask) f1: u32, |
| @location(5) @interpolate(flat) f2: vec3u |
| } |
| |
| @fragment |
| fn fragment0(a0: S2) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| _ = textureLoad(st13, vec2i()); |
| _ = a0.f3; |
| if bool(a0.f4[0]) { |
| out.f1 = u32(a0.f2); |
| } |
| return out; |
| } |
| struct FragmentOutput6 { |
| @location(0) f0: vec4f, |
| @location(3) f1: vec3u |
| } |
| |
| @fragment |
| fn fragment1(@location(12) @interpolate(flat, centroid) a0: vec2i) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 3, 2) |
| fn compute0(@builtin(num_workgroups) a0: vec3u) { |
| }`, |
| sourceMap: {}, |
| }); |
| let buffer27 = device0.createBuffer({ |
| size: 1520, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let texture59 = device0.createTexture({ |
| size: [150, 24, 146], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer26, 1_708); }; |
| } catch {} |
| try { |
| renderPassEncoder0.draw(163, 46, 1_379_202_287, 105_278_238); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer21, 1_096); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer19, 368); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'astc-10x5-unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['stencil8'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let texture60 = device0.createTexture({size: [659], dimension: '1d', format: 'r32uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({ |
| label: '\u3598\ue59d\u06a3\u0363\ua5d8\uc5f0\u0615\u6ff4\uc9fa\uc734\u083b', |
| colorFormats: ['rgb10a2unorm'], |
| stencilReadOnly: true, |
| }); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 37.25, |
| lodMaxClamp: 40.62, |
| }); |
| try { |
| computePassEncoder32.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(23); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(246, 408, 46, -1_671_282_748, 342_225_657); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer15, 424); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer4, 'uint32', 1_888, 11_948); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline4); |
| } catch {} |
| let bindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 184, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 187, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let texture61 = device0.createTexture({ |
| size: {width: 720, height: 1, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler26 = device0.createSampler({ |
| label: '\u093a\u0482\u{1fdc4}\ue9af', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 35.50, |
| lodMaxClamp: 96.41, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup8, new Uint32Array(7338), 3_662, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.setBlendConstant({ r: -277.3, g: -604.2, b: 73.12, a: -237.5, }); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 2_516); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer1, 'uint32', 3_972, 8_446); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(7, buffer13, 4_056, 7_065); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| document.body.prepend(canvas0); |
| let textureView42 = texture61.createView({}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder28.setBindGroup(0, bindGroup9, new Uint32Array(218), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(363, 75, 99_718_389, 505_560_537); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(7, 29, 2, 492_711_019, 452_771_610); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup13, new Uint32Array(932), 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.insertDebugMarker('\u{1fd82}'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 9} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 0, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture42, |
| mipLevel: 2, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer28 = device0.createBuffer({ |
| label: '\u7960\u{1fc15}\uad28\u{1f7df}\ue0c3\uc1f0\ucfc0\u{1fef0}\uec7a\ud027\u0750', |
| size: 776, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| let texture62 = device0.createTexture({ |
| size: [600, 96, 1], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle3 = renderBundleEncoder3.finish({}); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder3.setBlendConstant({ r: -192.8, g: 567.5, b: 144.3, a: -884.8, }); |
| } catch {} |
| try { |
| renderPassEncoder6.setViewport(465.04216919462556, 2.2611228625869795, 275.8476298761777, 1.1885449171939508, 0.8949620082591845, 0.9832125065957904); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(111, 330, 823_197_495, 354_697_002); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer19, 5_576); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer1, 'uint32', 2_672, 2_303); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline0); |
| } catch {} |
| document.body.append(video0); |
| let renderBundle4 = renderBundleEncoder4.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(156, 364, 235, 413_317_947, 388_906_840); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer15, 320); |
| } catch {} |
| let bindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 190, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let textureView43 = texture34.createView({baseMipLevel: 4, mipLevelCount: 1}); |
| try { |
| renderPassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| document.body.append(video0); |
| let texture63 = device0.createTexture({ |
| label: '\u053b\u67f6\u5344\ubdc5\u2456\u{1f72c}\u{1f6ca}', |
| size: {width: 659}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let sampler27 = device0.createSampler({ |
| label: '\u61f3\u25f3\u{1f797}\u2221\u9a75\u{1f998}', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 51.72, |
| lodMaxClamp: 68.98, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer15, 40); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setStencilReference(784); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(7, 103, 166_452_412, 1_603_811_103); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer26, 'uint16', 2_022, 537); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u{1ff67}'); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let imageData8 = new ImageData(28, 256); |
| let commandEncoder51 = device0.createCommandEncoder(); |
| let computePassEncoder34 = commandEncoder51.beginComputePass({}); |
| let sampler28 = device0.createSampler({ |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 90.47, |
| lodMaxClamp: 94.21, |
| maxAnisotropy: 8, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder34.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder7.setViewport(0.2730755925069712, 1.8970560032706294, 0.39505084576296395, 0.035111632997385823, 0.243111973580715, 0.7600152692660341); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(228, 92, 1_860_273_493, 336_422_265); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer15, 292); |
| } catch {} |
| let buffer29 = device0.createBuffer({size: 7880, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true}); |
| try { |
| renderPassEncoder0.drawIndexed(5, 319, 4, -1_565_276_778, 1_374_329_771); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer21, 64); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer20, 'uint32', 312, 3_576); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(6, buffer6, 64, 291); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let buffer30 = device0.createBuffer({ |
| size: 38516, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let textureView44 = texture58.createView({label: '\u0cd6\u{1feae}\u01ab\u0a5f', format: 'rgb10a2unorm', baseMipLevel: 0, mipLevelCount: 1}); |
| let renderPassEncoder15 = commandEncoder52.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: 372.8, g: 598.1, b: 199.0, a: 173.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 52318295, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup18, new Uint32Array(3230), 1_232, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(201, 14, 303_138_271, 251_023_607); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(19, 100, 1, -1_997_863_758, 1_174_820_820); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer19, 128); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 1452, new DataView(new ArrayBuffer(18175)), 11005, 652); |
| } catch {} |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let texture64 = device0.createTexture({ |
| size: {width: 75}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder16 = commandEncoder53.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: -530.3, g: 993.4, b: -72.68, a: 539.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| let sampler29 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 92.85, |
| lodMaxClamp: 98.79, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup9, new Uint32Array(517), 102, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 212, 202, 358_933_349, 369_065_431); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(143, 24, 229_506_985, 1_034_647_546); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 1_488); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer26, 1_956); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer23, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| video0.requestVideoFrameCallback((now, metadata) => { metadata.length = now; }); |
| let imageData9 = new ImageData(12, 212); |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte240m', transfer: 'log'} }); |
| let buffer31 = device0.createBuffer({ |
| size: 13320, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let querySet6 = device0.createQuerySet({label: '\u6046\u961d\u{1fe34}\uf879\ub572\u{1f800}', type: 'occlusion', count: 268}); |
| let texture65 = device0.createTexture({ |
| size: {width: 600, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup7, new Uint32Array(1206), 256, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup8, new Uint32Array(1114), 225, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(147, 81, 828_096_415, 103_969_505); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 424, new BigUint64Array(1396), 17, 248); |
| } catch {} |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup12, new Uint32Array(278), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle2, renderBundle0, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder2.setViewport(1.549799600905873, 0.8126215227269211, 0.11258726317838613, 0.9183251331302565, 0.7357454219233819, 0.8965724265963582); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(21, 11, 334_426_485, 1_315_288_552); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(341, 26, 609, 287_783_491, 2_130_182_646); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer16, 3_768); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer21, 'uint16', 704, 12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 280, new BigUint64Array(4168), 250, 84); |
| } catch {} |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'film', transfer: 'iec61966-2-1'} }); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer6, offset: 256, size: 912}}], |
| }); |
| let textureView45 = texture17.createView({label: '\ue159\u0e2f', format: 'rgb10a2unorm', baseMipLevel: 0}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 268, 0, 552_725_705, 352_217_394); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer20, 'uint16', 6, 1_376); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 13, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(168).fill(51), /* required buffer size: 168 */ |
| {offset: 168, bytesPerRow: 522, rowsPerImage: 8}, {width: 31, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer32 = device0.createBuffer({size: 11548, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let computePassEncoder35 = commandEncoder54.beginComputePass({}); |
| let sampler30 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 55.05, |
| lodMaxClamp: 93.14, |
| compare: 'never', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder35.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(188, 94, 764_867_797, 283_135_719); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(4, buffer23, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 88, new DataView(new ArrayBuffer(7438)), 2612, 444); |
| } catch {} |
| let buffer33 = device0.createBuffer({ |
| size: 25096, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let texture66 = device0.createTexture({size: [164], dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let textureView46 = texture11.createView({mipLevelCount: 1}); |
| let sampler31 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 23.64, |
| lodMaxClamp: 51.35, |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer26, 'uint32', 36, 197); |
| } catch {} |
| let texture67 = device0.createTexture({ |
| size: [150, 24, 1], |
| sampleCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture68 = device0.createTexture({size: [8, 5, 1], format: 'astc-8x5-unorm', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup6, new Uint32Array(3530), 588, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup20, new Uint32Array(236), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([]); |
| } catch {} |
| try { |
| renderPassEncoder0.setViewport(1.925307470569754, 1.5831013035643067, 0.0002450487447390862, 0.2398021177566733, 0.7486169039603174, 0.774590418177564); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer16, 7_320); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 880, new Float32Array(10839), 945, 96); |
| } catch {} |
| document.body.append(video0); |
| let buffer34 = device0.createBuffer({size: 1913, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let textureView47 = texture67.createView({}); |
| let computePassEncoder36 = commandEncoder55.beginComputePass({}); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup10, new Uint32Array(1344), 752, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0, renderBundle2, renderBundle2, renderBundle2, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(107, 88, 822_187_731, 1_749_393_516); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer26, 'uint16', 2_404, 221); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(5, buffer20, 1_120, 779); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(video0); |
| await gc(); |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 16 max align: 16 */ |
| struct T0 { |
| @size(16) f0: array<atomic<i32>>, |
| } |
| /* target size: 8 max align: 8 */ |
| struct T1 { |
| @align(1) @size(8) f0: vec2h, |
| } |
| @group(0) @binding(49) var st14: texture_storage_2d_array<r32float, write>; |
| @group(0) @binding(374) var st15: texture_storage_2d_array<rgba16float, read>; |
| @group(0) @binding(15) var tex1: texture_depth_2d_array; |
| @group(0) @binding(234) var sam1: sampler; |
| struct VertexOutput5 { |
| @builtin(position) f20: vec4f |
| } |
| |
| @vertex |
| fn vertex0(@location(2) @interpolate(flat) a0: vec2i) -> VertexOutput5 { |
| var out: VertexOutput5; |
| _ = a0; |
| if bool(textureSampleLevel(tex1, sam1, vec2f(), 0i, 0i)) { |
| var v: vec4f; |
| } |
| return out; |
| } |
| struct FragmentOutput7 { |
| @location(0) @interpolate(flat) f0: vec4f, |
| @location(3) @interpolate(flat) f1: vec2i, |
| @location(5) @interpolate(flat, centroid) f2: vec2f |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| _ = textureLoad(st15, vec2i(), 0); |
| }`, |
| }); |
| let bindGroup21 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [ |
| {binding: 234, resource: sampler25}, |
| {binding: 49, resource: textureView4}, |
| {binding: 374, resource: textureView35}, |
| {binding: 15, resource: textureView16}, |
| ], |
| }); |
| let buffer35 = device0.createBuffer({ |
| label: '\u0ac8\uffc4\u{1f856}\u0934\uf1a3\u4508\u5eaa\u{1f632}\u05b8\u2cf5\u070d', |
| size: 6738, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView48 = texture31.createView({}); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup10, []); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(279, 39, 363_424_453, 1_326_383_941); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer17, 1_828); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer21, 32); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| let pipeline6 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule1, entryPoint: 'compute1', constants: {}}}); |
| let bindGroup22 = device0.createBindGroup({ |
| label: '\u0e88\u0265\u2177', |
| layout: bindGroupLayout8, |
| entries: [{binding: 190, resource: textureView7}], |
| }); |
| let sampler32 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 1.970, |
| lodMaxClamp: 78.95, |
| }); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 202, 0, 355_697_344, 1_459_036_512); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer21, 1_204); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer8, 216); |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| label: '\u832a\uda8b\u2a07\u82c9\u3215\ueec6\u0024\u{1f8b4}', |
| layout: bindGroupLayout7, |
| entries: [{binding: 184, resource: {buffer: buffer23, offset: 256}}, {binding: 187, resource: textureView42}], |
| }); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true}); |
| let renderBundle5 = renderBundleEncoder5.finish({label: '\u09af\u{1f83d}\u2a6e\ufa99\u83d9'}); |
| let sampler33 = device0.createSampler({ |
| label: '\uab5a\u0188\u916f\u1530', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| lodMinClamp: 53.98, |
| lodMaxClamp: 74.13, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(175, 199, 453_893_720, 264_060_599); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer21, 208); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [ |
| {binding: 234, resource: sampler14}, |
| {binding: 374, resource: textureView28}, |
| {binding: 15, resource: textureView42}, |
| {binding: 49, resource: textureView4}, |
| ], |
| }); |
| let texture69 = device0.createTexture({ |
| size: [2880, 4, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(3, buffer33, 196, 2_759); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer19, 916); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder56.copyTextureToTexture({ |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 53}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 517, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| window.someLabel = buffer31.label; |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup18, new Uint32Array(879), 104, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer33, 5_348); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer16, 3_640); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(1, buffer3, 1_232, 1_222); |
| } catch {} |
| try { |
| commandEncoder56.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 1, |
| origin: {x: 271, y: 21, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture42, |
| mipLevel: 2, |
| origin: {x: 3, y: 1, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 9, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder57 = device0.createCommandEncoder(); |
| let computePassEncoder37 = commandEncoder56.beginComputePass({label: '\ufb0f\u2b13\u3657\u0db1\u0528\u7a01\u619f\u098d\u1082\u{1f782}\u{1f824}'}); |
| try { |
| computePassEncoder35.setBindGroup(0, bindGroup6, new Uint32Array(1727), 216, 0); |
| } catch {} |
| try { |
| computePassEncoder37.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup24, new Uint32Array(709), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(295, 31, 747_141_561, 613_554_382); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(36, 182, 1, 781_268_398, 815_906_823); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(4_294_967_294, undefined, 2_627_388_578, 242_752_341); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(43).fill(48), /* required buffer size: 43 */ |
| {offset: 43}, {width: 1204, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture70 = device0.createTexture({size: [2, 2, 12], format: 'rgb10a2unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, viewFormats: []}); |
| try { |
| renderPassEncoder3.draw(258, 449, 1_356_502_241, 483_492_511); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer17, 496); |
| } catch {} |
| let commandEncoder58 = device0.createCommandEncoder({label: '\uc622\u07d0\uef68'}); |
| let textureView49 = texture62.createView({mipLevelCount: 1}); |
| let renderPassEncoder17 = commandEncoder57.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 0, |
| clearValue: { r: -920.3, g: 373.3, b: 560.4, a: -834.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], stencilReadOnly: true}); |
| let renderBundle6 = renderBundleEncoder6.finish(); |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder11.setScissorRect(20, 6, 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(116, 40, 81_986_996, 611_148_771); |
| } catch {} |
| try { |
| commandEncoder58.copyBufferToBuffer(buffer21, 2032, buffer1, 44, 128); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToBuffer({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 4, y: 13, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 160 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 136 */ |
| offset: 136, |
| bytesPerRow: 256, |
| buffer: buffer5, |
| }, {width: 40, height: 74, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder5.insertDebugMarker('\uf72a'); |
| } catch {} |
| let bindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 92, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup25 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer4, offset: 512, size: 7196}}], |
| }); |
| let computePassEncoder38 = commandEncoder58.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup7, new Uint32Array(8848), 3_226, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setScissorRect(88, 13, 12, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(1, 153, 20, 686_248_372, 3_887_247_679); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer26, 'uint32', 536, 2_019); |
| } catch {} |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 92.14, |
| lodMaxClamp: 97.16, |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderPassEncoder2.drawIndexed(0, 25, 0, 186_835_037, 141_878_379); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer33, 1_908); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline5); |
| } catch {} |
| let buffer36 = device0.createBuffer({size: 33412, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let computePassEncoder39 = commandEncoder59.beginComputePass({label: '\ubfcc\u0624\u5e44\u03c4\u0581\u09fa'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle2, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder12.setScissorRect(9, 1, 4, 11); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 568, new BigUint64Array(3426), 1206, 104); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 659, height: 48, depthOrArrayLayers: 37} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 334, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let externalTexture2 = device0.importExternalTexture({label: '\u9dd2\u143c', source: videoFrame6}); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup12, new Uint32Array(4875), 1_103, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup10, new Uint32Array(110), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(52, 128, 9_304_360, 754_561_424); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer33, 2_008); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer26, 316); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'log'} }); |
| let bindGroup26 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView1}]}); |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout4, bindGroupLayout6]}); |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let computePassEncoder40 = commandEncoder60.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup4, new Uint32Array(1908), 204, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(0, 1, 1_300_035_915, 105_455_347); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 1, 1, 148_112_733, 1_119_361_639); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer16, 2_028); |
| } catch {} |
| let bindGroup27 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [ |
| {binding: 234, resource: sampler11}, |
| {binding: 374, resource: textureView35}, |
| {binding: 15, resource: textureView42}, |
| {binding: 49, resource: textureView2}, |
| ], |
| }); |
| let sampler35 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 1.266, |
| lodMaxClamp: 21.14, |
| compare: 'greater-equal', |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder40.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer8, 368); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 168, new Float32Array(18909), 1603, 68); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'gamma22curve'} }); |
| let bindGroup28 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView7}]}); |
| let texture71 = device0.createTexture({ |
| size: [329, 24, 1], |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| try { |
| computePassEncoder38.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 31, 2, 716_935_733, 915_221_773); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer33, 3_432); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 1256, new Int16Array(2916), 343, 336); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let imageData10 = new ImageData(76, 68); |
| let bindGroup29 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView24}]}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup13, new Uint32Array(1607), 451, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer4, 0, 4_243); |
| } catch {} |
| let arrayBuffer2 = buffer33.getMappedRange(); |
| document.body.prepend(img0); |
| let texture72 = device0.createTexture({ |
| size: {width: 75}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer19, 700); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer20, 'uint32', 400, 1_873); |
| } catch {} |
| try { |
| renderPassEncoder0.pushDebugGroup('\u02f2'); |
| } catch {} |
| try { |
| renderPassEncoder0.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 1, |
| origin: {x: 8, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(266).fill(28), /* required buffer size: 266 */ |
| {offset: 266, bytesPerRow: 249}, {width: 24, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 51 max align: 1 */ |
| struct T0 { |
| @align(1) @size(51) f0: array<f16>, |
| } |
| @group(1) @binding(64) var<storage, read_write> buffer37: T0; |
| @group(0) @binding(374) var st17: texture_storage_2d<rgba8unorm, read>; |
| @group(0) @binding(234) var sam2: sampler; |
| @group(0) @binding(49) var st16: texture_storage_2d_array<r32float, write>; |
| @group(0) @binding(15) var tex2: texture_cube<i32>; |
| struct VertexOutput6 { |
| @location(12) f21: vec4i, |
| @location(10) f22: vec2i, |
| @builtin(position) f23: vec4f, |
| @location(2) @interpolate(perspective, sample) f24: vec3h |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput6 { |
| var out: VertexOutput6; |
| return out; |
| } |
| struct VertexOutput7 { |
| @builtin(position) f25: vec4f |
| } |
| |
| @vertex |
| fn vertex1(@location(8) a0: vec4i) -> VertexOutput7 { |
| var out: VertexOutput7; |
| return out; |
| } |
| struct VertexOutput8 { |
| @location(1) f26: vec3h, |
| @builtin(position) f27: vec4f, |
| @location(11) f28: vec2i, |
| @location(14) f29: i32 |
| } |
| |
| @vertex |
| fn vertex2() -> VertexOutput8 { |
| var out: VertexOutput8; |
| return out; |
| } |
| struct FragmentOutput8 { |
| @location(0) f0: vec4i, |
| @location(1) f1: i32 |
| } |
| |
| @fragment |
| fn fragment0(@location(12) @interpolate(flat, centroid) a0: vec2i) -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| _ = buffer37.f0; |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| _ = buffer37.f0; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroup30 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView13}]}); |
| let buffer38 = device0.createBuffer({ |
| size: 2791, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let sampler36 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 32.38, |
| lodMaxClamp: 60.65, |
| compare: 'greater', |
| maxAnisotropy: 6, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer21, 1_684); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup29, new Uint32Array(564), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer27, 88); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer33, 'uint16', 852, 813); |
| } catch {} |
| try { |
| window.someLabel = device0.queue.label; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer8, 600); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer21, 540); |
| } catch {} |
| video0.height = 40; |
| let buffer39 = device0.createBuffer({ |
| size: 9429, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder0.draw(62, 46, 725_380_239, 288_472_775); |
| } catch {} |
| let pipeline7 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE, |
| }], |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 488, |
| attributes: [ |
| {format: 'float32x2', offset: 36, shaderLocation: 10}, |
| {format: 'uint32x3', offset: 20, shaderLocation: 0}, |
| {format: 'unorm16x2', offset: 276, shaderLocation: 11}, |
| {format: 'uint16x2', offset: 12, shaderLocation: 8}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'back'}, |
| }); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(212, 13); |
| let sampler37 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 20.44, |
| lodMaxClamp: 52.96, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup30, new Uint32Array(4820), 1_836, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(7, 81, 0, 276_396_102, 1_500_725_605); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 1_740); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline7); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer40 = device0.createBuffer({size: 10405, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let texture73 = device0.createTexture({ |
| size: [164, 12, 1], |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle2, renderBundle0, renderBundle2, renderBundle2, renderBundle2, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder9.setViewport(1.8013534030344511, 1.002980540528928, 0.10884621020809879, 0.36798458563393227, 0.4322180447725763, 0.5767859604470452); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer38, 416); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer26, 'uint32', 4_092, 402); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| await gc(); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder2.draw(213, 116, 237_143_041, 1_293_876_168); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(1, 51, 0, -2_086_958_055, 883_838_251); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer17, 104); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer26, 1_668); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer21, 'uint32', 52, 2_985); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup14, []); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToBuffer(buffer27, 4, buffer26, 1832, 632); |
| } catch {} |
| await gc(); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [ |
| {binding: 234, resource: sampler14}, |
| {binding: 49, resource: textureView4}, |
| {binding: 15, resource: textureView16}, |
| {binding: 374, resource: textureView28}, |
| ], |
| }); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let textureView50 = texture38.createView({format: 'rg32float', mipLevelCount: 1}); |
| let computePassEncoder41 = commandEncoder62.beginComputePass({}); |
| let renderBundle7 = renderBundleEncoder7.finish(); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 12, 1, 113_782_603, 69_201_654); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer8, 140); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 41, y: 5, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3728 */ |
| offset: 3728, |
| buffer: buffer9, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView24}]}); |
| let pipelineLayout7 = device0.createPipelineLayout({label: '\u0ddd\ue77e\u002a\ua12c', bindGroupLayouts: []}); |
| let computePassEncoder42 = commandEncoder61.beginComputePass(); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder2.drawIndirect(buffer19, 76); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer21, 'uint32', 940, 15); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(6, buffer31, 0, 1_295); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({layout: pipelineLayout5, compute: {module: shaderModule6, constants: {}}}); |
| let textureView51 = texture36.createView({ |
| label: '\u82be\u2104\uad06\u{1f952}\u2ad5\u0e35\u{1f61c}\u0e4c\u9a63\u{1fcd9}', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| }); |
| let sampler38 = device0.createSampler({ |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 30.70, |
| lodMaxClamp: 67.53, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder42.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(118, 738, 833_400_747, 2_595_086_446); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(7, 85, 47, 560_324_541, 974_996_425); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer26, 5_400); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer40, 2_072); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer31, 1_896, 329); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup31, new Uint32Array(1247), 55, 0); |
| } catch {} |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let texture74 = device0.createTexture({ |
| label: '\u3e00\u1c7e\u0d98', |
| size: {width: 1440, height: 2, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder43 = commandEncoder63.beginComputePass({}); |
| try { |
| renderPassEncoder2.drawIndexed(1, 0, 5, 257_409_492, 445_067_373); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 600); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer26, 2_068); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(7, buffer39, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup24, new Uint32Array(292), 76, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let video1 = await videoWithData(28); |
| let imageData11 = new ImageData(72, 8); |
| let buffer41 = device0.createBuffer({ |
| size: 6475, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder64 = device0.createCommandEncoder(); |
| let texture75 = device0.createTexture({ |
| size: [2880], |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder18 = commandEncoder64.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView23, |
| clearValue: { r: 886.3, g: 912.6, b: -611.7, a: 493.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 165041506, |
| }); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup19, new Uint32Array(3261), 201, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer40, 8); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer19, 768); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(1, buffer31, 3_092, 1_146); |
| } catch {} |
| try { |
| adapter0.label = '\u{1f954}\u085f\u3b22\u7532\ub831\u6fb1\u{1f9ab}\u{1f896}'; |
| } catch {} |
| let texture76 = device0.createTexture({ |
| size: [659, 48, 1], |
| sampleCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle8 = renderBundleEncoder9.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer40, 2_208); }; |
| } catch {} |
| try { |
| computePassEncoder43.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(1, 174, 21, 29_624_016, 1_274_281_416); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer19, 724); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer26, 564); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer4, 'uint32', 5_788, 2_741); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup28); |
| } catch {} |
| try { |
| buffer33.unmap(); |
| } catch {} |
| let imageData12 = new ImageData(20, 4); |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteRp431', transfer: 'gamma28curve'} }); |
| let bindGroup33 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 598, resource: {buffer: buffer26, offset: 256}}]}); |
| let commandEncoder65 = device0.createCommandEncoder(); |
| let sampler39 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 84.72, |
| lodMaxClamp: 99.20, |
| }); |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup26, new Uint32Array(1969), 190, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(38); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(290, 59, 2_079_341_813, 1_157_173_198); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup1, new Uint32Array(1859), 167, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder65.resolveQuerySet(querySet0, 73, 30, buffer35, 2048); |
| } catch {} |
| document.body.append(canvas0); |
| let texture77 = device0.createTexture({ |
| size: [82], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup13, new Uint32Array(565), 13, 0); |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer13, 'uint16', 9_124, 2_138); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup20, new Uint32Array(619), 29, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(1, buffer30, 4_204); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 75, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 8, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture48, |
| mipLevel: 2, |
| origin: {x: 2, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer42 = device0.createBuffer({ |
| size: 194, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true}); |
| let externalTexture3 = device0.importExternalTexture({label: '\u891f\u544c', source: video0}); |
| try { |
| renderPassEncoder2.draw(26, 24, 3_386_950_954, 280_130_250); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 74, 0, 207_803_886, 237_131_136); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer27, 'uint16', 76, 399); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let gpuCanvasContext1 = offscreenCanvas0.getContext('webgpu'); |
| let bindGroup34 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer39, offset: 1792, size: 816}}], |
| }); |
| let querySet7 = device0.createQuerySet({type: 'occlusion', count: 2389}); |
| let computePassEncoder44 = commandEncoder65.beginComputePass({}); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup9, new Uint32Array(635), 87, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(228), 143, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(193, 41, 420_536_303, 65_498_062); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(2, buffer25); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 2, |
| origin: {x: 6, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(566).fill(147), /* required buffer size: 566 */ |
| {offset: 566, bytesPerRow: 19}, {width: 2, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| try { |
| window.someLabel = textureView5.label; |
| } catch {} |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let textureView52 = texture12.createView({}); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup22, new Uint32Array(1270), 546, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(19, 221, 3, 66_886_297, 750_872_488); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer41, 760); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 1_008); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer6, 'uint32', 4_504, 970); |
| } catch {} |
| document.body.prepend(img0); |
| let imageBitmap1 = await createImageBitmap(videoFrame2); |
| let buffer43 = device0.createBuffer({ |
| label: '\u01a6\u00d0\ue573\ubbf9\u{1fe0c}\u09b9\u0226\u24f9\u01dc\u{1fde0}\u{1fc71}', |
| size: 37476, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let sampler40 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 67.07, |
| lodMaxClamp: 75.30, |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup1, new Uint32Array(1269), 64, 0); |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup34, new Uint32Array(1146), 208, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 17, 0, 237_974_582, 1_602_207_812); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer33, 880); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer4, 'uint32', 9_992, 3_819); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer33, 4_144, 2_009); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup29, new Uint32Array(338), 6, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder66.copyTextureToTexture({ |
| texture: texture76, |
| mipLevel: 0, |
| origin: {x: 82, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture76, |
| mipLevel: 0, |
| origin: {x: 94, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 26, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder45 = commandEncoder66.beginComputePass({}); |
| let renderBundle9 = renderBundleEncoder10.finish({}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup30, new Uint32Array(1799), 10, 0); |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 57, 1, 193_361_507, 1_021_218_654); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer26, 1_456); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup19, new Uint32Array(274), 13, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer21, 'uint32', 1_232, 77); |
| } catch {} |
| let imageData13 = new ImageData(24, 20); |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let texture78 = device0.createTexture({ |
| label: '\u{1fde4}\u{1fa5e}\ucd95\u0032\uf6b2\u07e8\u{1fd01}\u00d2\u00ad\u{1ff1c}', |
| size: [164, 12, 1], |
| mipLevelCount: 4, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView53 = texture34.createView({baseMipLevel: 1, mipLevelCount: 3}); |
| let sampler41 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 54.89, |
| lodMaxClamp: 85.84, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder29.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup1, new Uint32Array(7), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(2239.033632522668, 0.9028405916517586, 121.08832340949864, 2.2921072228922035, 0.8684074676109135, 0.9105831475751095); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer42, 40); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(7, buffer30, 0, 8_278); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup0, new Uint32Array(562), 24, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 1652, new Float32Array(27343), 3010, 516); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let bindGroup35 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView32}]}); |
| let buffer44 = device0.createBuffer({size: 4524, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let texture79 = device0.createTexture({ |
| label: '\u1e94\uae1d', |
| size: [360, 1, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView54 = texture23.createView({}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setViewport(0.9386239969241326, 1.9246597790756488, 0.7626821117227068, 0.017838531679916152, 0.5634271071825455, 0.7471913316477027); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer38, 84); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer6, 'uint32', 1_392, 363); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(3, buffer39, 0, 1_273); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let shaderModule8 = device0.createShaderModule({ |
| label: '\u09a6\uc523\u9a87\u5168\u1f67\u0685\u437b\u1b2c\u{1fceb}', |
| code: ` |
| enable f16; |
| /* target size: 85 max align: 1 */ |
| struct T0 { |
| @align(1) @size(25) f0: atomic<u32>, |
| @align(1) @size(8) f1: array<i32, 1>, |
| @align(1) f2: mat2x4h, |
| @align(1) @size(36) f3: array<array<atomic<u32>, 1>>, |
| } |
| @group(0) @binding(80) var st18: texture_storage_3d<r32sint, read_write>; |
| @group(1) @binding(80) var st19: texture_storage_2d<r32float, read_write>; |
| @group(2) @binding(80) var st20: texture_storage_2d<r32float, read_write>; |
| struct FragmentOutput9 { |
| @location(1) @interpolate(flat, center) f0: vec2i, |
| @location(0) @interpolate(flat) f1: vec4i |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool) -> FragmentOutput9 { |
| var out: FragmentOutput9; |
| return out; |
| } |
| |
| @compute @workgroup_size(4, 1, 1) |
| fn compute0(@builtin(local_invocation_id) a0: vec3u) { |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 187, resource: textureView42}, |
| {binding: 184, resource: {buffer: buffer8, offset: 256, size: 771}}, |
| ], |
| }); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let textureView55 = texture41.createView({mipLevelCount: 1}); |
| let sampler42 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 97.87, |
| lodMaxClamp: 99.73, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup12, new Uint32Array(408), 46, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer8, 1_856); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer15, 408); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer33, 'uint16', 3_990, 5_246); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup36, new Uint32Array(550), 79, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(4, buffer33, 2_240, 1_343); |
| } catch {} |
| try { |
| computePassEncoder39.pushDebugGroup('\u3f3c'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 157, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(229).fill(22), /* required buffer size: 229 */ |
| {offset: 229, bytesPerRow: 136, rowsPerImage: 53}, {width: 25, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder46 = commandEncoder68.beginComputePass({}); |
| let renderBundle10 = renderBundleEncoder11.finish({}); |
| let sampler43 = device0.createSampler({ |
| label: '\u98f0\ubc7f\u{1fd58}\u0800', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 26.70, |
| lodMaxClamp: 34.47, |
| maxAnisotropy: 3, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer42, 76); }; |
| } catch {} |
| try { |
| computePassEncoder46.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer42, 'uint16', 72, 2); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder67.copyTextureToBuffer({ |
| texture: texture75, |
| mipLevel: 0, |
| origin: {x: 204, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 972 widthInBlocks: 972 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 9 */ |
| offset: 9, |
| buffer: buffer34, |
| }, {width: 972, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer45 = device0.createBuffer({ |
| label: '\u5fce\ufe4e\u{1f91b}\u04bd\u3d3b\ub8a8\u0ede\u3270\u944f', |
| size: 12461, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture80 = device0.createTexture({ |
| label: '\u0661\ucf67\u5a9f\u374b\u329f\u0266\ue1af\u{1f72b}\u17b6', |
| size: {width: 2880, height: 4, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder47 = commandEncoder67.beginComputePass({}); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup15, new Uint32Array(855), 204, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle3, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer15, 2_556); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer8, 212); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer20, 'uint32', 4_844, 437); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(4, buffer31); |
| } catch {} |
| let texture81 = device0.createTexture({ |
| size: {width: 360, height: 1, depthOrArrayLayers: 1}, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView56 = texture76.createView({label: '\u0017\u051b\u053b\u649f', dimension: '2d'}); |
| try { |
| computePassEncoder47.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(42); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(226, 85, 832_712_418, 45_346_500); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer8, 1_344); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer45, 3_448); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer39, 0, 555); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup10, new Uint32Array(3007), 55, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpteSt4281', transfer: 'log'} }); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let querySet8 = device0.createQuerySet({type: 'occlusion', count: 158}); |
| let computePassEncoder48 = commandEncoder69.beginComputePass({}); |
| let sampler44 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 85.66, |
| lodMaxClamp: 88.65, |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder48.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup29, new Uint32Array(610), 47, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(7, buffer31); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup1, new Uint32Array(393), 26, 0); |
| } catch {} |
| try { |
| for (let i = 0; i < 10459; ++i) { if (i%1000 === 0) await device0.queue.onSubmittedWorkDone(); for (let j = 0; j < 313; ++j) renderBundleEncoder8.draw(0); renderBundleEncoder8.setPipeline(pipeline7); renderBundleEncoder8.setPipeline(pipeline4); }; |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(2, 12, 8, 257_405_808, 1_285_731_030); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer20, 'uint32', 908, 3_023); |
| } catch {} |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let computePassEncoder49 = commandEncoder70.beginComputePass(); |
| let renderBundle11 = renderBundleEncoder8.finish({}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder46.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup3, new Uint32Array(2092), 461, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(92, 8, 1_030_515_456, 12_825_433); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer4, 'uint32', 1_308, 22_647); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let shaderModule9 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 51 max align: 1 */ |
| struct T0 { |
| @align(1) @size(42) f0: mat2x4h, |
| @align(1) f1: i32, |
| @align(1) @size(5) f2: i32, |
| } |
| @group(0) @binding(374) var st22: texture_storage_2d<rgba8unorm, read>; |
| @group(0) @binding(234) var sam3: sampler; |
| @group(1) @binding(64) var<storage, read_write> buffer46: array<T0>; |
| @group(0) @binding(15) var tex3: texture_3d<i32>; |
| @group(0) @binding(49) var st21: texture_storage_2d<rgba32uint, write>; |
| struct VertexOutput9 { |
| @location(8) f30: vec4u, |
| @builtin(position) f31: vec4f, |
| @location(5) @interpolate(flat) f32: vec2i, |
| @location(15) f33: vec3i, |
| @location(9) @interpolate(flat, sample) f34: vec2u |
| } |
| |
| @vertex |
| fn vertex0(@location(3) @interpolate(flat) a0: vec4h) -> VertexOutput9 { |
| var out: VertexOutput9; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute0() { |
| if bool(buffer46[arrayLength(&buffer46)].f2) { |
| return; |
| } |
| if bool(textureLoad(st22, vec2i())[1]) { |
| buffer46[12345].f1 &= i32(-91); |
| } |
| }`, |
| hints: {}, |
| }); |
| let querySet9 = device0.createQuerySet({type: 'occlusion', count: 933}); |
| let texture82 = device0.createTexture({ |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup19, new Uint32Array(2088), 80, 0); |
| } catch {} |
| try { |
| computePassEncoder49.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 255, 0, 107_202_023, 713_089_920); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer41, 3_624); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer39, 0); |
| } catch {} |
| let buffer47 = device0.createBuffer({ |
| size: 430, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(58, 239, 1_277_468_478, 119_978_379); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 25, 0, 38_859_209, 206_635_565); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder39.popDebugGroup(); |
| } catch {} |
| let img1 = await imageWithData(12, 7, '#10101010', '#20202020'); |
| let bindGroup37 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 28, resource: {buffer: buffer36, offset: 12032}}]}); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let sampler45 = device0.createSampler({ |
| label: '\u72ed\u0769\u{1ff0f}\u0b13', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 75.52, |
| lodMaxClamp: 82.33, |
| compare: 'not-equal', |
| maxAnisotropy: 16, |
| }); |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(1_489, 210, 692, -1_920_670_320, 992_648_483); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(video0); |
| let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let textureView57 = texture6.createView({label: '\u763b\u3a27\u{1f975}\u0f7e\u{1fbf0}\u97a8\u{1f7d5}', dimension: 'cube', baseArrayLayer: 1}); |
| try { |
| renderPassEncoder0.draw(29, 307, 624_484_074, 97_452_594); |
| } catch {} |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let computePassEncoder50 = commandEncoder71.beginComputePass({}); |
| let externalTexture5 = device0.importExternalTexture({source: video0}); |
| try { |
| computePassEncoder50.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup1, new Uint32Array(1880), 841, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(228); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle3, renderBundle3, renderBundle9, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(97, 219, 0, 519_623_095, 223_460_083); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2960 */ |
| offset: 2960, |
| buffer: buffer18, |
| }, { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder51 = commandEncoder72.beginComputePass({}); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup10, new Uint32Array(4326), 72, 0); |
| } catch {} |
| try { |
| computePassEncoder48.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(32, 139, 41_036_795, 515_318_429); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer20, 'uint32', 2_040, 7_005); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer32, 6052, buffer1, 3176, 460); |
| } catch {} |
| document.body.prepend(img1); |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'iec61966-2-1'} }); |
| let promise7 = adapter0.requestAdapterInfo(); |
| let commandEncoder75 = device0.createCommandEncoder(); |
| let texture83 = device0.createTexture({ |
| size: {width: 659, height: 48, depthOrArrayLayers: 471}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let computePassEncoder52 = commandEncoder75.beginComputePass({}); |
| try { |
| computePassEncoder52.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup34, new Uint32Array(755), 164, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(114, 29, 513_648_934, 2_110_251_946); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 124, 0, 555_772_026, 348_259_306); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer27, 36); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(2, buffer6, 708, 1_552); |
| } catch {} |
| let imageData14 = new ImageData(16, 4); |
| let buffer48 = device0.createBuffer({ |
| size: 16718, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder76 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder1.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer26, 4_712); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let commandEncoder77 = device0.createCommandEncoder(); |
| let texture84 = device0.createTexture({size: [360, 1, 1], dimension: '2d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []}); |
| try { |
| computePassEncoder50.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup7, new Uint32Array(245), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle2, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(4, 52, 138, 17_366_591, 96_358_576); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer6, 'uint32', 80, 1_647); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer9, 856); |
| } catch {} |
| try { |
| device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 84, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(18).fill(6), /* required buffer size: 18 */ |
| {offset: 18}, {width: 196, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let textureView58 = texture57.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer19, 2_412); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer41, 172); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder76.copyBufferToTexture({ |
| /* bytesInLastRow: 92 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 248 */ |
| offset: 248, |
| buffer: buffer12, |
| }, { |
| texture: texture48, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 23, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture85 = device0.createTexture({ |
| size: [360, 1, 1], |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder53 = commandEncoder78.beginComputePass(); |
| try { |
| computePassEncoder48.setBindGroup(3, bindGroup29, new Uint32Array(916), 238, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder4.draw(1, 92, 739_894_573, 900_877_197); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer21, 548); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer20, 'uint16', 6_658, 170); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder(); |
| let textureView59 = texture63.createView({aspect: 'all'}); |
| let computePassEncoder54 = commandEncoder74.beginComputePass({}); |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(27, 170, 118_289_149, 44_922_504); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(1_144, 19, 383, 35_491_401, 1_027_269_263); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer15, 404); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 312); |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 90, resource: textureView10}]}); |
| let textureView60 = texture70.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6}); |
| let computePassEncoder55 = commandEncoder79.beginComputePass(); |
| let sampler46 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 75.52, |
| compare: 'never', |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup32, new Uint32Array(3539), 235, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(381, 5, 20_308_200, 44_765_680); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(59, 262, 1, 759_853_960, 1_189_526_966); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer19, 2_764); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(5, buffer3); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer48, 2620, new Int16Array(629), 409, 8); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup39 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [ |
| {binding: 374, resource: textureView28}, |
| {binding: 234, resource: sampler24}, |
| {binding: 49, resource: textureView2}, |
| {binding: 15, resource: textureView16}, |
| ], |
| }); |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| let textureView61 = texture67.createView({aspect: 'all'}); |
| let computePassEncoder56 = commandEncoder80.beginComputePass({label: '\u{1fcb9}\u0914\ucfde\u02a6\u775e\u4721\ua704\u6025\u088e'}); |
| let sampler47 = device0.createSampler({addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMinClamp: 27.74}); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup5, new Uint32Array(4042), 157, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup26, new Uint32Array(2823), 468, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer41, 120); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture86 = device0.createTexture({ |
| label: '\ua665\udf6f\u08d7\u21e9\u423a\u0648\uea0a\u{1f62a}\u0405', |
| size: [82, 6, 132], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture6 = device0.importExternalTexture({source: video1}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup18, new Uint32Array(1520), 362, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(52, 114, 132_852_222, 327_427_433); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(1_027, 132, 1_114, 864_033_808, 882_791_754); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer15, 848); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer26, 'uint32', 964, 38); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer31, 3_064, 1_470); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToTexture({ |
| /* bytesInLastRow: 2732 widthInBlocks: 683 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1656 */ |
| offset: 1656, |
| buffer: buffer22, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 61, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 683, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 644, new Float32Array(8412), 178, 1036); |
| } catch {} |
| let buffer49 = device0.createBuffer({ |
| label: '\u8641\u01ee\u793d\u2a58\u0117\u5573\u3482\u{1f9dc}\u229d\u{1fe0f}\ude4d', |
| size: 52723, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView62 = texture67.createView({}); |
| let texture87 = device0.createTexture({ |
| label: '\u{1f7a9}\u{1fc23}', |
| size: [1440, 2, 1], |
| mipLevelCount: 4, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder19 = commandEncoder76.beginRenderPass({colorAttachments: [{view: textureView12, depthSlice: 187, loadOp: 'load', storeOp: 'store'}]}); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder55.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer26, 248); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup21, []); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToBuffer(buffer12, 748, buffer26, 1372, 1448); |
| } catch {} |
| try { |
| commandEncoder81.resolveQuerySet(querySet4, 95, 22, buffer24, 512); |
| } catch {} |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let texture88 = device0.createTexture({ |
| size: {width: 1440}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer45, 88); }; |
| } catch {} |
| try { |
| renderPassEncoder4.draw(18, 221, 1_013_405_178, 1_578_946_103); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 98, 0, 422_640_973, 659_170_568); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup4, new Uint32Array(2476), 256, 0); |
| } catch {} |
| try { |
| commandEncoder77.copyTextureToBuffer({ |
| texture: texture75, |
| mipLevel: 0, |
| origin: {x: 228, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 688 widthInBlocks: 688 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 609 */ |
| offset: 609, |
| bytesPerRow: 1792, |
| buffer: buffer34, |
| }, {width: 688, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 64, resource: {buffer: buffer30, offset: 2304}}]}); |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| let computePassEncoder57 = commandEncoder73.beginComputePass(); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup20, new Uint32Array(1325), 34, 0); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder57.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 173, 1, 39_568_659, 1_088_878_588); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer16, 3_076); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup4, new Uint32Array(2394), 146, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 5, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(60).fill(39), /* required buffer size: 60 */ |
| {offset: 60, bytesPerRow: 453}, {width: 27, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 360, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 1167, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let texture89 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder58 = commandEncoder84.beginComputePass({}); |
| let renderBundle12 = renderBundleEncoder12.finish({label: '\ue6e9\u0345\u0066\u82ab\u0474\u06e0\ua50f\uab97\u7bc1\u9f3e'}); |
| try { |
| computePassEncoder43.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup20, new Uint32Array(763), 39, 0); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup20, new Uint32Array(2270), 775, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setViewport(0.5211561249868246, 1.484537691978992, 0.2210386942211099, 0.24727019542052747, 0.0663787650578701, 0.19788777948802821); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(126, 42, 392_799_831, 3_032_373_348); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(95, 286, 29, 416_321_489, 3_659_980_473); |
| } catch {} |
| try { |
| renderPassEncoder11.insertDebugMarker('\u{1fb4f}'); |
| } catch {} |
| document.body.append(canvas0); |
| let canvas1 = document.createElement('canvas'); |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte240m', transfer: 'smpteSt4281'} }); |
| let computePassEncoder59 = commandEncoder77.beginComputePass({label: '\ucc05\u78dc'}); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup7, new Uint32Array(2483), 65, 0); |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup9, new Uint32Array(696), 219, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(36, 4, 152, 65_204_447, 127_393_701); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer19, 488); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer21, 664); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 107, y: 13, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(510).fill(94), /* required buffer size: 510 */ |
| {offset: 510, bytesPerRow: 309, rowsPerImage: 94}, {width: 57, height: 53, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 169}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup30); |
| } catch {} |
| try { |
| computePassEncoder56.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndirect(buffer21, 780); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer49, 'uint16', 5_896, 711); |
| } catch {} |
| try { |
| commandEncoder83.clearBuffer(buffer26); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder47.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup15, new Uint32Array(515), 144, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndexedIndirect(buffer19, 2_116); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer13, 'uint16', 14_522, 328); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer13); |
| } catch {} |
| try { |
| commandEncoder85.copyBufferToBuffer(buffer45, 4416, buffer44, 172, 924); |
| } catch {} |
| try { |
| commandEncoder81.copyTextureToTexture({ |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 206, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 11, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 78, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 224, new BigUint64Array(11244), 842, 172); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 24, depthOrArrayLayers: 15} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 1, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 11, y: 1, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup41 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView13}]}); |
| let texture90 = device0.createTexture({ |
| label: '\u1b63\uf3b5\u07df\u2d34\u393d\u2d00\u05c5', |
| size: [659, 48, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder60 = commandEncoder85.beginComputePass({}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup36, new Uint32Array(702), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(62.06336250001556, 2.8819494227706755, 2629.5339479836216, 1.0976259206411252, 0.4476884961031329, 0.4853292582738292); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer26, 1_524); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer45, 372); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 7, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(119).fill(113), /* required buffer size: 119 */ |
| {offset: 119}, {width: 16, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| try { |
| computePassEncoder60.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder10.draw(62, 83, 644_350_550, 340_327_190); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder81.copyBufferToBuffer(buffer45, 1728, buffer6, 4180, 240); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let computePassEncoder61 = commandEncoder82.beginComputePass({label: '\ue2b2\u{1fffc}\u04bf\u6da5'}); |
| try { |
| computePassEncoder34.setPipeline(pipeline8); |
| } catch {} |
| try { |
| computePassEncoder53.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup9, new Uint32Array(1166), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(194, 203, 105_261_123, 480_553_484); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer16, 524); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(6, buffer42, 0); |
| } catch {} |
| let arrayBuffer3 = buffer29.getMappedRange(); |
| let pipeline9 = device0.createRenderPipeline({ |
| layout: pipelineLayout5, |
| fragment: {module: shaderModule6, targets: [{format: 'bgra8unorm-srgb', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [{arrayStride: 1076, attributes: [{format: 'sint32x4', offset: 56, shaderLocation: 2}]}], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front'}, |
| }); |
| await gc(); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let textureView63 = texture5.createView({}); |
| let computePassEncoder62 = commandEncoder86.beginComputePass({}); |
| try { |
| computePassEncoder54.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(158, 1, 858_993_371, 93_644_179); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer38, 168); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer8, 'uint32', 1_256, 357); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let buffer50 = device0.createBuffer({ |
| label: '\u6796\u{1fc90}\u{1fd52}\u0e34\uf630', |
| size: 14517, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup6, new Uint32Array(89), 6, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1, 2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(19, 76, 3, 88_349_356, 453_384_884); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer13, 'uint16', 14_636, 7_040); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 4, y: 14 }, |
| flipY: false, |
| }, { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(118, 95); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let textureView64 = texture66.createView({baseMipLevel: 0}); |
| let computePassEncoder63 = commandEncoder88.beginComputePass({}); |
| try { |
| computePassEncoder63.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(26); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 40, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(45).fill(179), /* required buffer size: 45 */ |
| {offset: 45, bytesPerRow: 87}, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| video0.height = 26; |
| let bindGroup42 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer30, offset: 3584, size: 3568}}], |
| }); |
| let computePassEncoder64 = commandEncoder87.beginComputePass({label: '\u098a\u78ce\u010c\u{1f944}'}); |
| let renderPassEncoder20 = commandEncoder83.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView51, |
| clearValue: { r: 25.27, g: 762.3, b: 794.5, a: -550.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder62.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(15, 130, 2_294_860_339, 1_023_039_423); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer40, 3_204); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer13, 'uint32', 9_608, 181); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let buffer51 = device0.createBuffer({ |
| size: 36203, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let commandBuffer3 = commandEncoder81.finish({}); |
| try { |
| computePassEncoder61.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder10.draw(105, 656, 259_435_603, 668_369_055); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer13, 'uint32', 4_396, 383); |
| } catch {} |
| try { |
| commandEncoder89.copyTextureToTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 258, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 37, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 34, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'etc2-rgb8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['stencil8'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let buffer52 = device0.createBuffer({ |
| label: '\uf96e\u0038\u3b21\u06ae\uab40', |
| size: 21136, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView65 = texture6.createView({ |
| label: '\uf33d\u76f4\u9354\u{1f90e}\uc941\u086d\u197b\u3dbf\u0ed5\u08b6', |
| dimension: 'cube-array', |
| mipLevelCount: 1, |
| arrayLayerCount: 6, |
| }); |
| try { |
| computePassEncoder64.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder19.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(110, 60, 5_849_157, 329_644_241); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndexed(55, 199, 9, -2_102_260_732, 1_434_937_938); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer50, 472); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer41, 524); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); }); |
| } catch {} |
| let texture91 = device0.createTexture({ |
| size: [600, 96, 88], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder65 = commandEncoder89.beginComputePass({}); |
| let sampler48 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMinClamp: 64.61, |
| lodMaxClamp: 77.95, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder64.end(); |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer19, 3_752); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline7); |
| } catch {} |
| try { |
| computePassEncoder43.pushDebugGroup('\u717d'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 2, depthOrArrayLayers: 297} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 129}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer17, 1_784); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup42, new Uint32Array(1030), 33, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(70, 158, 1_584_079_485, 1_216_202_892); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 23, 0, 473_253_181, 1_484_660_078); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer19, 804); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer48, 672); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer1, 'uint16', 8_502, 12_525); |
| } catch {} |
| try { |
| commandEncoder87.copyBufferToBuffer(buffer45, 1472, buffer1, 3220, 440); |
| } catch {} |
| try { |
| renderPassEncoder13.insertDebugMarker('\u22dc'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| let commandEncoder90 = device0.createCommandEncoder(); |
| let querySet11 = device0.createQuerySet({label: '\u0a17\u0033\u4ce3\u015f\u0aa4\u8501\ua133\ue275', type: 'occlusion', count: 506}); |
| let texture92 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba32sint'], |
| }); |
| let renderPassEncoder21 = commandEncoder87.beginRenderPass({colorAttachments: [{view: textureView23, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| computePassEncoder30.dispatchWorkgroups(1, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(5); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(465, 23, 755_154_492, 1_441_474_446); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 81, 1, 331_849_629, 692_175_380); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer26, 2_284); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToBuffer(buffer16, 3712, buffer15, 1640, 1388); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer34, 40, new Float32Array(8691), 647, 56); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| document.body.prepend(canvas1); |
| let textureView66 = texture60.createView({}); |
| let sampler49 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 44.06, |
| lodMaxClamp: 44.85, |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder53.setBindGroup(2, bindGroup22, new Uint32Array(331), 85, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder13.setBlendConstant({ r: 324.2, g: 411.1, b: 152.3, a: 744.8, }); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndexedIndirect(buffer40, 4_620); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(3, buffer42, 0, 26); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 416 */ |
| offset: 416, |
| buffer: buffer14, |
| }, { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu'); |
| let shaderModule10 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 16 max align: 16 */ |
| struct T0 { |
| @align(1) f0: array<array<f16, 1>, 8>, |
| } |
| @group(2) @binding(80) var st25: texture_storage_3d<r32float, read_write>; |
| @group(0) @binding(80) var st23: texture_storage_3d<r32float, read_write>; |
| @group(1) @binding(80) var st24: texture_storage_1d<r32uint, read_write>; |
| struct VertexOutput10 { |
| @builtin(position) f35: vec4f |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput10 { |
| var out: VertexOutput10; |
| return out; |
| } |
| struct FragmentOutput10 { |
| @location(0) @interpolate(linear, center) f0: vec4f, |
| @builtin(sample_mask) f1: u32, |
| @builtin(frag_depth) f2: f32 |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput10 { |
| var out: FragmentOutput10; |
| out.f1 += u32(84); |
| return out; |
| } |
| |
| @compute @workgroup_size(5, 1, 1) |
| fn compute0() { |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroup43 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 589, resource: {buffer: buffer45, offset: 1280, size: 677}}, |
| {binding: 19, resource: textureView53}, |
| {binding: 168, resource: sampler0}, |
| ], |
| }); |
| let texture93 = device0.createTexture({ |
| size: [659, 48, 1], |
| dimension: '2d', |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder10.draw(14, 192, 1_485_048_715, 599_993_867); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(8, 60, 169, 293_732_595, 449_747_352); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer41, 2_236); |
| } catch {} |
| let promise8 = shaderModule7.getCompilationInfo(); |
| try { |
| buffer31.unmap(); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1296 */ |
| offset: 1296, |
| buffer: buffer12, |
| }, { |
| texture: texture78, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 101, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(61).fill(25), /* required buffer size: 61 */ |
| {offset: 61, bytesPerRow: 746}, {width: 185, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 148} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 6, y: 107 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 40}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 187, resource: textureView62}, |
| {binding: 184, resource: {buffer: buffer42, offset: 0, size: 3}}, |
| ], |
| }); |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup17, new Uint32Array(2071), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(333, 122, 1_541_090_704, 1_664_979_225); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(30, 88, 49, 67_065_533, 810_664_162); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer8, 412); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToBuffer(buffer48, 804, buffer33, 1228, 64); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| label: '\u7ac2\u{1f837}\u08d8\u3503\u05df\u34f4\u0d46\ued54\u{1f8f2}', |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer6, offset: 1280}}], |
| }); |
| let buffer53 = device0.createBuffer({ |
| size: 2519, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let textureView67 = texture67.createView({}); |
| let computePassEncoder66 = commandEncoder90.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer15, 400); }; |
| } catch {} |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline8); |
| } catch {} |
| try { |
| computePassEncoder66.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(3, bindGroup35); |
| } catch {} |
| let buffer54 = device0.createBuffer({size: 3940, usage: GPUBufferUsage.MAP_WRITE, mappedAtCreation: true}); |
| let computePassEncoder67 = commandEncoder91.beginComputePass(); |
| let renderPassEncoder22 = commandEncoder15.beginRenderPass({ |
| colorAttachments: [{view: textureView48, depthSlice: 0, loadOp: 'load', storeOp: 'store'}], |
| maxDrawCount: 94665991, |
| }); |
| try { |
| computePassEncoder67.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup4, new Uint32Array(484), 124, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 373, 0, 48_515_501, 369_166_387); |
| } catch {} |
| try { |
| buffer41.destroy(); |
| } catch {} |
| let gpuCanvasContext3 = canvas1.getContext('webgpu'); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let textureView68 = texture88.createView({format: 'rgb10a2unorm'}); |
| let sampler50 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMinClamp: 36.17, lodMaxClamp: 76.83}); |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup13, new Uint32Array(16), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup44, new Uint32Array(394), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndexed(35, 226, 5, 423_332_223, 685_810_259); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer16, 7_492); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer27, 'uint32', 608, 60); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(5, buffer35, 0, 843); |
| } catch {} |
| try { |
| querySet0.destroy(); |
| } catch {} |
| let bindGroup46 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 187, resource: textureView42}, |
| {binding: 184, resource: {buffer: buffer13, offset: 7168, size: 867}}, |
| ], |
| }); |
| let texture94 = device0.createTexture({ |
| size: [150, 24, 1], |
| sampleCount: 4, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler51 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 54.36, |
| lodMaxClamp: 91.59, |
| }); |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer50, 'uint32', 116, 416); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer26.unmap(); |
| } catch {} |
| let computePassEncoder68 = commandEncoder92.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer51, 840); }; |
| } catch {} |
| try { |
| computePassEncoder68.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 34, 0, -1_515_364_187, 1_383_819_192); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer33, 7_160); |
| } catch {} |
| try { |
| computePassEncoder43.popDebugGroup(); |
| } catch {} |
| let textureView69 = texture60.createView({mipLevelCount: 1}); |
| let texture95 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(2, bindGroup19, new Uint32Array(3515), 855, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup14, new Uint32Array(832), 370, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.drawIndexed(9, 284, 18, -2_134_165_268, 290_123_071); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer27, 'uint16', 662, 96); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let sampler52 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 61.80, |
| lodMaxClamp: 68.27, |
| maxAnisotropy: 5, |
| }); |
| try { |
| renderPassEncoder10.draw(179, 197, 193_408_779, 833_515_047); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(3, 343, 0, 326_721_791, 3_452_527_516); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer27, 120); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer13, 'uint32', 6_564, 4_527); |
| } catch {} |
| let imageData15 = new ImageData(96, 20); |
| let externalTexture7 = device0.importExternalTexture({source: video0, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer16, 4_212); }; |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer33, 2_048); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({label: '\u961c\u12fa'}); |
| let textureView70 = texture76.createView({mipLevelCount: 1}); |
| let computePassEncoder69 = commandEncoder93.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder34.setPipeline(pipeline6); |
| } catch {} |
| try { |
| computePassEncoder69.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer38, 452); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline5); |
| } catch {} |
| try { |
| computePassEncoder59.pushDebugGroup('\uda72'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 172, new Float32Array(1097)); |
| } catch {} |
| let pipeline10 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}}); |
| let bindGroup47 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{binding: 184, resource: {buffer: buffer52, offset: 1280}}, {binding: 187, resource: textureView42}], |
| }); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let commandBuffer4 = commandEncoder94.finish({label: '\ud416\u{1fc7a}\u0e4e\u26b6\u0ce1\u{1f9a5}\u0659\ueaa8\u5c3f\u{1f779}\u{1fa07}'}); |
| try { |
| renderPassEncoder8.draw(8, 240, 111_946_577, 471_053_403); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| label: '\u6fc2\u1b22\u0cce\u001b\u0d81\u0aec\u{1fbc7}\u875b\u0a91', |
| layout: bindGroupLayout6, |
| entries: [{binding: 64, resource: {buffer: buffer51, offset: 3584, size: 1288}}], |
| }); |
| let texture96 = device0.createTexture({ |
| size: {width: 600, height: 96, depthOrArrayLayers: 138}, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup28, new Uint32Array(358), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup4, new Uint32Array(2221), 302, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(135, 376, 319_011_773, 104_452_194); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(127, 111, 20, 65_945_748, 319_093_158); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer50, 2_548); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer27, 276); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer42, 'uint16', 10, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 1120, new DataView(new ArrayBuffer(4254)), 144, 96); |
| } catch {} |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'r16sint'], depthReadOnly: true, stencilReadOnly: false}); |
| let renderBundle13 = renderBundleEncoder13.finish({}); |
| try { |
| renderPassEncoder2.executeBundles([renderBundle11, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder13.setBlendConstant({ r: 165.7, g: 346.6, b: 131.9, a: 904.3, }); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(0, 67, 8, 381_932_540, 680_471_738); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer16, 564); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer8, 'uint16', 488, 232); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer3, 68); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let computePassEncoder70 = commandEncoder95.beginComputePass({}); |
| try { |
| computePassEncoder70.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(3, 319, 631_627_382, 359_880_525); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer38, 196); |
| } catch {} |
| let arrayBuffer4 = buffer23.getMappedRange(632); |
| let imageData16 = new ImageData(44, 56); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder15.beginOcclusionQuery(52); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder4.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(51, 99, 20_753, 1_604_722_670); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer16, 2_980); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(4, buffer53, 0, 24); |
| } catch {} |
| try { |
| commandEncoder96.copyBufferToBuffer(buffer21, 212, buffer53, 540, 108); |
| } catch {} |
| try { |
| commandEncoder96.copyTextureToBuffer({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2748 */ |
| offset: 2748, |
| rowsPerImage: 214, |
| buffer: buffer21, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder4.insertDebugMarker('\u0702'); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let computePassEncoder71 = commandEncoder96.beginComputePass({}); |
| let sampler53 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 82.76, |
| lodMaxClamp: 87.23, |
| }); |
| try { |
| computePassEncoder60.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder48.setBindGroup(3, bindGroup10, new Uint32Array(94), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup20, new Uint32Array(9899), 498, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(23, 553, 3_454_246, 167_004_480); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 417, 0, -2_074_630_226, 708_999_359); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer8, 536); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer21, 1_048); |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 187, resource: textureView42}, |
| {binding: 184, resource: {buffer: buffer9, offset: 2560, size: 2888}}, |
| ], |
| }); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let texture97 = device0.createTexture({size: [150, 24, 46], dimension: '3d', format: 'rgba32float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let computePassEncoder72 = commandEncoder97.beginComputePass({}); |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder41.setBindGroup(2, bindGroup25, new Uint32Array(266), 9, 0); |
| } catch {} |
| try { |
| computePassEncoder72.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup19, new Uint32Array(18), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(92, 93, 13, 78_335_908, 10_793_153); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer40, 344); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer23, 0, 521); |
| } catch {} |
| let texture98 = device0.createTexture({ |
| label: '\u0da6\u{1ffe8}', |
| size: [720], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder20.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer40, 56); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline7); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(30, 719); |
| try { |
| offscreenCanvas2.getContext('bitmaprenderer'); |
| } catch {} |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let textureView71 = texture79.createView({label: '\ud6e6\u{1ff04}\u0cdf\ua6fb\u053c\u1d73\u295f', dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder73 = commandEncoder98.beginComputePass({}); |
| try { |
| computePassEncoder71.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder7.setBlendConstant({ r: 973.9, g: -52.16, b: -735.4, a: 24.85, }); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer33, 44); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| offscreenCanvas0.height = 512; |
| try { |
| computePassEncoder55.setBindGroup(3, bindGroup22, new Uint32Array(2066), 83, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup29, new Uint32Array(1570), 815, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer17, 164); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer42, 'uint16', 34, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer31); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| try { |
| computePassEncoder59.popDebugGroup(); |
| } catch {} |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup48, new Uint32Array(1194), 78, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 183, 0, 63_588_128, 79_783_483); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer26, 'uint32', 888, 651); |
| } catch {} |
| try { |
| computePassEncoder72.insertDebugMarker('\u0bd8'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 10, y: 1, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(1_240_495).fill(31), /* required buffer size: 1_240_495 */ |
| {offset: 121, bytesPerRow: 1021, rowsPerImage: 86}, {width: 55, height: 11, depthOrArrayLayers: 15}); |
| } catch {} |
| let imageData17 = new ImageData(28, 116); |
| let bindGroup50 = device0.createBindGroup({ |
| label: '\u0ac1\u2657\ueac1\u061f\u7d83\u7390\u3937\u0453\u03ea', |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 184, resource: {buffer: buffer42, offset: 0, size: 21}}, |
| {binding: 187, resource: textureView47}, |
| ], |
| }); |
| try { |
| computePassEncoder3.dispatchWorkgroupsIndirect(buffer51, 4_232); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(61, 123, 787_685_585, 385_798_176); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 227, 0, 48_618_550, 997_576_530); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer48, 9_504); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer49, 'uint16', 1_146, 2_699); |
| } catch {} |
| let buffer55 = device0.createBuffer({size: 4283, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let computePassEncoder74 = commandEncoder99.beginComputePass({}); |
| let sampler54 = device0.createSampler({ |
| label: '\u041d\u5d93\u0caf\u0f94\u{1faf6}\u700a\u08d5\u4610\uebb2\uaffe', |
| addressModeU: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 77.03, |
| lodMaxClamp: 83.01, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer8, 'uint32', 736, 298); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder(); |
| let sampler55 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.17, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder66.setBindGroup(0, bindGroup35, new Uint32Array(590), 308, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer40, 2_664); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToBuffer(buffer21, 192, buffer0, 268, 228); |
| } catch {} |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let texture99 = device0.createTexture({ |
| size: [600, 96, 1], |
| mipLevelCount: 2, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView72 = texture28.createView({label: '\u771a\u0c5f\u9a33\u{1fac8}\u8845\u4665\u0b77\u0765'}); |
| let computePassEncoder75 = commandEncoder101.beginComputePass({}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup3, new Uint32Array(507), 56, 0); |
| } catch {} |
| try { |
| computePassEncoder75.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(3, 111, 11, -2_111_637_838, 146_279_187); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer52, 3_600); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer27, 'uint32', 236, 39); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToBuffer(buffer27, 152, buffer48, 1584, 616); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToTexture({ |
| /* bytesInLastRow: 84 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 600 */ |
| offset: 600, |
| bytesPerRow: 256, |
| buffer: buffer30, |
| }, { |
| texture: texture36, |
| mipLevel: 1, |
| origin: {x: 6, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 21, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder100.copyTextureToTexture({ |
| texture: texture52, |
| mipLevel: 1, |
| origin: {x: 28, y: 0, z: 30}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture27, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'smpte240m'} }); |
| let commandEncoder102 = device0.createCommandEncoder({label: '\u0af9\u{1f649}\ue37a'}); |
| let texture100 = device0.createTexture({ |
| size: {width: 82, height: 6, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView73 = texture79.createView({dimension: '2d-array', format: 'rgb10a2unorm', mipLevelCount: 1}); |
| let computePassEncoder76 = commandEncoder100.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer27, 40); }; |
| } catch {} |
| try { |
| computePassEncoder76.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer52, 8_056); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer15, 440); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer49, 'uint16', 18, 1_891); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| try { |
| computePassEncoder32.pushDebugGroup('\u01cd'); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [ |
| {binding: 234, resource: sampler13}, |
| {binding: 49, resource: textureView5}, |
| {binding: 374, resource: textureView28}, |
| {binding: 15, resource: textureView16}, |
| ], |
| }); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let texture101 = device0.createTexture({ |
| size: [75, 12, 353], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder77 = commandEncoder103.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder77.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(488, 60, 1_153_578_754, 226_862_852); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer26, 'uint32', 7_028, 642); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 64, resource: {buffer: buffer42, offset: 0, size: 44}}], |
| }); |
| let computePassEncoder78 = commandEncoder102.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder78.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder7.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer15, 592); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer1, 'uint32', 10_276, 3_519); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 329, height: 24, depthOrArrayLayers: 18} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture42, |
| mipLevel: 1, |
| origin: {x: 27, y: 2, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 335, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 80, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 633, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 83, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 130, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 169, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 78, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 444, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 139, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView74 = texture93.createView({baseMipLevel: 0}); |
| let textureView75 = texture25.createView({}); |
| let sampler56 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'clamp-to-edge', magFilter: 'nearest', compare: 'not-equal'}); |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup6, new Uint32Array(715), 272, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 168, 0, 254_214_338, 2_520_966_474); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer50, 1_888); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| let arrayBuffer5 = buffer29.getMappedRange(7880, 0); |
| let bindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 106, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 66, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 81, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 59, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 315, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 347, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 48, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let buffer56 = device0.createBuffer({ |
| size: 28503, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let texture102 = device0.createTexture({ |
| size: {width: 82}, |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder79 = commandEncoder104.beginComputePass({}); |
| let sampler57 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'nearest', lodMinClamp: 33.21, lodMaxClamp: 42.95}); |
| try { |
| computePassEncoder79.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(122, 3, 1_080_097_930, 88_341_024); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 155, 0, 5_570_529, 269_996_998); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer15, 1_612); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer26, 'uint32', 1_908, 30); |
| } catch {} |
| let videoFrame15 = new VideoFrame(offscreenCanvas2, {timestamp: 0}); |
| let bindGroup53 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer9, offset: 1024, size: 1260}}], |
| }); |
| let commandEncoder105 = device0.createCommandEncoder({label: '\u60a4\u04f5'}); |
| let textureView76 = texture4.createView({dimension: '2d-array'}); |
| let texture103 = device0.createTexture({ |
| size: [2, 2, 12], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder80 = commandEncoder105.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer26, 1_200); }; |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(88, 23, 947_278_348, 118_588_161); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline7); |
| } catch {} |
| try { |
| computePassEncoder32.popDebugGroup(); |
| } catch {} |
| let img2 = await imageWithData(68, 22, '#10101010', '#20202020'); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let texture104 = device0.createTexture({ |
| size: [150], |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture105 = device0.createTexture({size: {width: 720}, dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder81 = commandEncoder106.beginComputePass(); |
| let sampler58 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 80.68, |
| lodMaxClamp: 89.58, |
| }); |
| try { |
| computePassEncoder80.setBindGroup(3, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder80.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer53, 56); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer27, 92); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer51); |
| } catch {} |
| let buffer57 = device0.createBuffer({ |
| size: 1909, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView77 = texture104.createView({dimension: '1d'}); |
| try { |
| computePassEncoder44.setBindGroup(0, bindGroup9, new Uint32Array(113), 69, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(1, 79, 1, 104_410_667, 268_713_625); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer26, offset: 4864, size: 680}}], |
| }); |
| let commandEncoder107 = device0.createCommandEncoder(); |
| let texture106 = device0.createTexture({ |
| size: [600, 96, 1], |
| mipLevelCount: 3, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder43.setBindGroup(1, bindGroup19, new Uint32Array(1784), 679, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder2.draw(277, 12, 56_023_772, 42_376_553); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer40, 1_272); |
| } catch {} |
| try { |
| commandEncoder107.copyTextureToTexture({ |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture58, |
| mipLevel: 1, |
| origin: {x: 140, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| let texture107 = device0.createTexture({ |
| size: {width: 329}, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture108 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder81.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 228, 0, 69_265_797, 811_909_554); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer45, 1_696); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer48, 5_520); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(5, buffer55, 0, 343); |
| } catch {} |
| try { |
| commandEncoder107.copyBufferToTexture({ |
| /* bytesInLastRow: 196 widthInBlocks: 49 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 444 */ |
| offset: 444, |
| buffer: buffer48, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 50, y: 6, z: 1}, |
| aspect: 'all', |
| }, {width: 49, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder107.resolveQuerySet(querySet7, 24, 1, buffer4, 6144); |
| } catch {} |
| try { |
| externalTexture0.label = '\u{1f798}\u9d87\u03b5\uced9\uced4\u3ab8\u896b\ua8fd\u1a13\u6104'; |
| } catch {} |
| let bindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 17, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 380, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup55 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 187, resource: textureView67}, |
| {binding: 184, resource: {buffer: buffer23, offset: 1024, size: 151}}, |
| ], |
| }); |
| let textureView78 = texture104.createView({dimension: '1d'}); |
| let renderPassEncoder23 = commandEncoder108.beginRenderPass({ |
| label: '\u0098\u087a\u32b4\uf308\u{1fca7}\u0bbb\u530e\u787e\u0d0b', |
| colorAttachments: [{ |
| view: textureView41, |
| depthSlice: 0, |
| clearValue: { r: -468.8, g: -115.6, b: 371.8, a: -941.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 134615779, |
| }); |
| let sampler59 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 4.157, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder71.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(277, 19, 1_885_898_603, 350_405_746); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 392, 0, 255_247_742, 1_932_215_868); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer13, 'uint16', 2_904, 4_552); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder107.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 996 */ |
| offset: 996, |
| bytesPerRow: 512, |
| buffer: buffer10, |
| }, { |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 42, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 20, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder3.insertDebugMarker('\ueb11'); |
| } catch {} |
| try { |
| texture29.label = '\u054a\u{1fe3f}\u{1fc4c}\u0f19'; |
| } catch {} |
| let buffer58 = device0.createBuffer({size: 19112, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let textureView79 = texture106.createView({ |
| label: '\u0184\u2ead\u09db\uc2c2\u0711\u3fe9\u244c\u0fcb', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 0, |
| }); |
| let computePassEncoder82 = commandEncoder107.beginComputePass(); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(162), 8, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(4); }; |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup12, new Uint32Array(1419), 329, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer16, 2_188); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 589, resource: {buffer: buffer42, offset: 0, size: 78}}, |
| {binding: 168, resource: sampler46}, |
| {binding: 19, resource: textureView63}, |
| ], |
| }); |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let texture109 = device0.createTexture({ |
| size: {width: 75}, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder83 = commandEncoder109.beginComputePass({}); |
| try { |
| renderPassEncoder3.drawIndexed(116, 30, 39, 388_716_760, 1_325_038_918); |
| } catch {} |
| let bindGroup57 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 184, resource: {buffer: buffer20, offset: 4864, size: 736}}, |
| {binding: 187, resource: textureView67}, |
| ], |
| }); |
| let buffer59 = device0.createBuffer({ |
| size: 1301, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture110 = device0.createTexture({ |
| size: [360], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer50, 5_456); }; |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(255, 19, 106, 891_414_995, 1_072_801_283); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer42, 4); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer40, 1_156); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 598, resource: {buffer: buffer19, offset: 512}}]}); |
| let buffer60 = device0.createBuffer({ |
| size: 3820, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture111 = device0.createTexture({ |
| size: [82], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame9, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder26.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup50, new Uint32Array(475), 83, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(96, 71, 17, 242_158_072, 1_411_344_296); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer41, 1_844); |
| } catch {} |
| let bindGroup59 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 64, resource: {buffer: buffer21, offset: 0, size: 1244}}], |
| }); |
| let textureView80 = texture107.createView({ |
| label: '\u{1f802}\u0cd1\u0c00\u{1fe9e}\uc8f7\u{1f7f2}\u3278\ue12f\u0143\ub9b5\ufda1', |
| baseArrayLayer: 0, |
| }); |
| let texture112 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView81 = texture27.createView({}); |
| let sampler60 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 21.18, |
| lodMaxClamp: 35.02, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder83.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup22, new Uint32Array(140), 44, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer33, 'uint32', 5_732, 4_385); |
| } catch {} |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true}); |
| let renderBundle14 = renderBundleEncoder14.finish({label: '\u0bf4\u{1fee8}\u0670\uf138\u660d\u026d\u08c7\u{1fdfb}'}); |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup53, new Uint32Array(1578), 250, 0); |
| } catch {} |
| try { |
| computePassEncoder82.setPipeline(pipeline10); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| let buffer61 = device0.createBuffer({ |
| size: 17364, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: true, |
| }); |
| try { |
| computePassEncoder71.setBindGroup(2, bindGroup36, new Uint32Array(546), 173, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 29, 0, 404_628_192, 101_464_693); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer42, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer59, 'uint16', 174, 95); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: bindGroupLayout10, |
| entries: [ |
| {binding: 335, resource: textureView10}, |
| {binding: 633, resource: textureView79}, |
| {binding: 139, resource: textureView27}, |
| {binding: 41, resource: textureView79}, |
| {binding: 80, resource: textureView74}, |
| {binding: 3, resource: textureView80}, |
| {binding: 78, resource: textureView50}, |
| {binding: 130, resource: {buffer: buffer52, offset: 0, size: 3736}}, |
| {binding: 444, resource: textureView49}, |
| {binding: 169, resource: textureView76}, |
| {binding: 83, resource: {buffer: buffer39, offset: 1536, size: 1488}}, |
| ], |
| }); |
| let buffer62 = device0.createBuffer({size: 16403, usage: GPUBufferUsage.MAP_WRITE}); |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup61 = device0.createBindGroup({ |
| label: '\u{1fad3}\u008a\ued1d', |
| layout: bindGroupLayout9, |
| entries: [{binding: 92, resource: textureView32}], |
| }); |
| let textureView82 = texture8.createView({label: '\ud450\u8df4\u5313\u{1fdd0}\uec7f\u8659\u1a4d\u0990\u00e6\u062d', aspect: 'all'}); |
| try { |
| renderPassEncoder2.draw(106, 104, 114_649_976, 1_155_302_996); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer33, 3_644); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(2, buffer35, 0, 452); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 40, new BigUint64Array(11662), 884, 44); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(227).fill(83), /* required buffer size: 227 */ |
| {offset: 227}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup62 = device0.createBindGroup({ |
| layout: bindGroupLayout10, |
| entries: [ |
| {binding: 444, resource: textureView44}, |
| {binding: 3, resource: textureView80}, |
| {binding: 335, resource: textureView20}, |
| {binding: 633, resource: textureView79}, |
| {binding: 169, resource: textureView76}, |
| {binding: 41, resource: textureView79}, |
| {binding: 83, resource: {buffer: buffer6, offset: 512}}, |
| {binding: 130, resource: {buffer: buffer30, offset: 6144}}, |
| {binding: 80, resource: textureView74}, |
| {binding: 78, resource: textureView56}, |
| {binding: 139, resource: textureView49}, |
| ], |
| }); |
| let texture113 = device0.createTexture({ |
| size: [150, 24, 17], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder2.draw(114, 27, 2_429_736_548, 399_410_242); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(3, 5, 1, 477_447_017, 826_141_946); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer21, 824); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer26, 296); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer42, 'uint16', 98, 15); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline0); |
| } catch {} |
| try { |
| querySet3.destroy(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(1_063).fill(18), /* required buffer size: 1_063 */ |
| {offset: 37, bytesPerRow: 54, rowsPerImage: 19}, {width: 3, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup63 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView13}]}); |
| let buffer63 = device0.createBuffer({ |
| label: '\u0a47\udec5\u2cb0\u0cab\u6a2b\u6434\u{1ff10}\u{1f715}', |
| size: 10082, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let querySet12 = device0.createQuerySet({type: 'occlusion', count: 68}); |
| let texture114 = device0.createTexture({ |
| size: [2], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(4, buffer39); |
| } catch {} |
| let sampler61 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 81.53, |
| lodMaxClamp: 94.02, |
| }); |
| try { |
| computePassEncoder44.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup63, new Uint32Array(1730), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -289.1, g: 596.3, b: 716.1, a: 95.22, }); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(38, 62, 191_077_240, 548_709_721); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 177, 0, 92_279_919, 1_143_039_785); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer49, 21_748); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(4, undefined, 34_039_185, 168_111_582); |
| } catch {} |
| try { |
| renderPassEncoder5.insertDebugMarker('\u{1fd9b}'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 720, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 70, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let bindGroupLayout13 = device0.createBindGroupLayout({ |
| label: '\ufaf5\u{1f9fa}\ua52a\u06ae\uc09c\u02b5\u09e3\ub266', |
| entries: [ |
| { |
| binding: 168, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture115 = device0.createTexture({ |
| size: {width: 1440, height: 2, depthOrArrayLayers: 51}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView83 = texture55.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer41, 992); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let texture116 = device0.createTexture({ |
| size: {width: 360, height: 1, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView84 = texture50.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder67.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(64, 340, 373_651_607, 367_895_697); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 205, 0, 496_536_008, 997_883_890); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer49, 20_700); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer16, 6_000); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer13, 'uint16', 1_120, 3_930); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer48, 1356, new Int16Array(3921), 1124, 300); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| document.body.append(video0); |
| let buffer64 = device0.createBuffer({ |
| size: 376, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder111 = device0.createCommandEncoder({label: '\u0020\ud251\ua7ae'}); |
| let computePassEncoder84 = commandEncoder111.beginComputePass({}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup17, new Uint32Array(2588), 423, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer19, 3_340); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer49, 516); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(0, buffer23, 444); |
| } catch {} |
| try { |
| commandEncoder110.copyTextureToBuffer({ |
| texture: texture95, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'depth-only', |
| }, { |
| /* bytesInLastRow: 300 widthInBlocks: 150 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 364 */ |
| offset: 364, |
| bytesPerRow: 512, |
| buffer: buffer53, |
| }, {width: 150, height: 24, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 720, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 257, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| try { |
| computePassEncoder61.label = '\ub5a3\ue522\u7832\u{1f71b}\u3000\u{1fd75}\u0c5c\u0d58'; |
| } catch {} |
| let bindGroup64 = device0.createBindGroup({ |
| label: '\u4527\u8e13\u8386\u0d51\u973e\u78e8\u8383\uca83\u{1fedf}', |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 168, resource: sampler23}, |
| {binding: 19, resource: textureView63}, |
| {binding: 589, resource: {buffer: buffer23, offset: 512, size: 1527}}, |
| ], |
| }); |
| let textureView85 = texture115.createView({baseMipLevel: 1, mipLevelCount: 1}); |
| let sampler62 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 2.271, |
| compare: 'equal', |
| }); |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup14, new Uint32Array(205), 55, 0); |
| } catch {} |
| try { |
| computePassEncoder84.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(128, 74, 190_501_697, 536_808_844); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 96, 4, 237_113_511, 404_342_193); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer19, 268); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer8, 'uint16', 1_292, 184); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 272 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2248 */ |
| offset: 2248, |
| rowsPerImage: 114, |
| buffer: buffer10, |
| }, { |
| texture: texture69, |
| mipLevel: 2, |
| origin: {x: 61, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 68, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 228, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(27).fill(109), /* required buffer size: 27 */ |
| {offset: 27, bytesPerRow: 266}, {width: 57, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup65 = device0.createBindGroup({ |
| layout: bindGroupLayout11, |
| entries: [ |
| {binding: 106, resource: {buffer: buffer30, offset: 18688, size: 1339}}, |
| {binding: 347, resource: textureView79}, |
| {binding: 66, resource: textureView74}, |
| {binding: 81, resource: textureView32}, |
| {binding: 315, resource: {buffer: buffer51, offset: 1024, size: 24}}, |
| {binding: 48, resource: textureView78}, |
| {binding: 59, resource: textureView69}, |
| {binding: 21, resource: {buffer: buffer38, offset: 0, size: 1212}}, |
| ], |
| }); |
| let buffer65 = device0.createBuffer({ |
| label: '\u{1fc3c}\u{1fdc7}\u{1f95b}', |
| size: 2540, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| mappedAtCreation: true, |
| }); |
| let texture117 = device0.createTexture({ |
| label: '\ua888\u0944\u05ac\u05b3\u0877\u0ce1\u5d7f\u{1fab0}\u081f\u{1fcbf}\ub365', |
| size: [300, 48, 1], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['depth16unorm'], |
| }); |
| let textureView86 = texture100.createView({dimension: '2d-array'}); |
| let computePassEncoder85 = commandEncoder110.beginComputePass(); |
| let sampler63 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 83.74, |
| lodMaxClamp: 91.24, |
| }); |
| try { |
| computePassEncoder85.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup65, new Uint32Array(315), 181, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(99, 32, 160_699_014, 45_913_897); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer42, 16); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder12.insertDebugMarker('\u0d75'); |
| } catch {} |
| let bindGroupLayout14 = device0.createBindGroupLayout({ |
| label: '\u0b32\ub080', |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let querySet13 = device0.createQuerySet({type: 'occlusion', count: 1843}); |
| let textureView87 = texture65.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(9, 292, 91_849_669, 962_222_025); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer48, 1_416); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer42, 'uint16', 0, 22); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer40.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView88 = texture4.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup35, new Uint32Array(4050), 681, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer60, 828); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline4); |
| } catch {} |
| document.body.append(img2); |
| let commandEncoder112 = device0.createCommandEncoder({label: '\u12b7\u9e9c\u71a6\u62d1\u9029\u0375\u1bc2\ueff3\u{1fa07}\u7f84\u{1f769}'}); |
| let computePassEncoder86 = commandEncoder112.beginComputePass(); |
| try { |
| computePassEncoder3.dispatchWorkgroups(1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer41, 1_444); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setViewport(6.382173887787396, 13.51732301520109, 125.752252103935, 7.694746620281777, 0.7696651751593993, 0.9280434181817896); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(136, 12, 106_657_824, 119_286_567); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer56, 12_568); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer59, 'uint16', 198, 227); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer30, 0, 1_603); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let texture118 = device0.createTexture({ |
| size: {width: 1440, height: 2, depthOrArrayLayers: 570}, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder84.setBindGroup(2, bindGroup32); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(1, bindGroup21, new Uint32Array(1392), 259, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer6); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder6.insertDebugMarker('\u0e05'); |
| } catch {} |
| let bindGroup66 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView1}]}); |
| let texture119 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 479}, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder4.draw(128, 304, 416_839_991, 454_611_970); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 153, 0, -1_895_675_496, 239_469_914); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer41, 1_008); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline7); |
| } catch {} |
| try { |
| buffer43.unmap(); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise10; |
| } catch {} |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let texture120 = device0.createTexture({ |
| size: {width: 2880, height: 4, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(43, 67, 167_653_022, 239_999_976); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let imageData18 = new ImageData(56, 40); |
| let buffer66 = device0.createBuffer({ |
| size: 19888, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder114 = device0.createCommandEncoder(); |
| let computePassEncoder87 = commandEncoder113.beginComputePass({}); |
| let sampler64 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 97.53, |
| lodMaxClamp: 99.46, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup12, new Uint32Array(736), 62, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer15, 2_300); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer1, 'uint16', 3_980, 8_992); |
| } catch {} |
| let textureView89 = texture106.createView({mipLevelCount: 1}); |
| let textureView90 = texture61.createView({dimension: '2d-array'}); |
| let computePassEncoder88 = commandEncoder114.beginComputePass({label: '\u0ac9\u8b00\u0d25\u05e5\u6b75\u1f9e\u072a'}); |
| try { |
| renderPassEncoder21.setBindGroup(1, bindGroup31, new Uint32Array(4539), 1_676, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle4, renderBundle0, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer63, 5_248); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer23, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer15, 184, new DataView(new ArrayBuffer(10052)), 806, 500); |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({label: '\u02b2\u3879\u2676\u075f\ue666\u071b\u{1fda2}\u090a'}); |
| let texture121 = device0.createTexture({size: {width: 2880}, dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder89 = commandEncoder115.beginComputePass({}); |
| try { |
| computePassEncoder43.setBindGroup(2, bindGroup15, new Uint32Array(242), 53, 0); |
| } catch {} |
| try { |
| computePassEncoder86.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup57, new Uint32Array(688), 40, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(2_606, 145, 33, 6_621_143, 1_178_829_919); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer50, 232); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(6, buffer50, 0, 7_794); |
| } catch {} |
| let promise11 = shaderModule6.getCompilationInfo(); |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let buffer67 = device0.createBuffer({ |
| size: 10409, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let computePassEncoder90 = commandEncoder116.beginComputePass({}); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup13, new Uint32Array(2173), 613, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(94, 37, 236, 1_174_994_766, 271_491_638); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer19, 996); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(1, buffer50, 136, 1_094); |
| } catch {} |
| let bindGroup67 = device0.createBindGroup({ |
| label: '\u4239\u{1fd62}\ufdd0\u3052\u{1fdbd}\u07f7\ud256', |
| layout: bindGroupLayout8, |
| entries: [{binding: 190, resource: textureView7}], |
| }); |
| let querySet14 = device0.createQuerySet({type: 'occlusion', count: 663}); |
| let sampler65 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 60.49, |
| lodMaxClamp: 60.74, |
| }); |
| try { |
| computePassEncoder45.setBindGroup(1, bindGroup38, new Uint32Array(1445), 98, 0); |
| } catch {} |
| try { |
| computePassEncoder68.end(); |
| } catch {} |
| try { |
| computePassEncoder88.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup57); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer16, 2_692); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer19, 3_496); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer50, 'uint32', 14_304, 115); |
| } catch {} |
| try { |
| commandEncoder92.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 428 */ |
| offset: 428, |
| rowsPerImage: 655, |
| buffer: buffer53, |
| }, { |
| texture: texture48, |
| mipLevel: 1, |
| origin: {x: 5, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(video1); |
| let buffer68 = device0.createBuffer({ |
| size: 2241, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 219}); |
| let computePassEncoder91 = commandEncoder92.beginComputePass({}); |
| let externalTexture10 = device0.importExternalTexture({source: video1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer48, 3_904); }; |
| } catch {} |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(303, 249, 88_830_022, 1_263_940_094); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer53, 376); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline5); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| document.body.prepend(video0); |
| let promise12 = adapter0.requestAdapterInfo(); |
| let bindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 92, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 368, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder118 = device0.createCommandEncoder(); |
| let textureView91 = texture95.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| let sampler66 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 67.48, |
| lodMaxClamp: 88.67, |
| maxAnisotropy: 20, |
| }); |
| let externalTexture11 = device0.importExternalTexture({label: '\u77e8\ud935\u{1ff32}\uf962\u07c6\u0249\ua716\u0563\u257d\u{1ff6b}', source: videoFrame10}); |
| try { |
| computePassEncoder91.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup6, new Uint32Array(2550), 47, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer48, 3_564); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer27, 'uint16', 26, 599); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 440, new Int16Array(9214)); |
| } catch {} |
| let computePassEncoder92 = commandEncoder117.beginComputePass({}); |
| try { |
| computePassEncoder89.setBindGroup(1, bindGroup52, new Uint32Array(2679), 18, 0); |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(51, 122, 269_268_112, 562_448_707); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer53, 444); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer50, 1_924); |
| } catch {} |
| try { |
| commandEncoder118.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 75, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 684, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 36, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup68 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView24}]}); |
| let buffer69 = device0.createBuffer({size: 12743, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder119 = device0.createCommandEncoder(); |
| let textureView92 = texture110.createView({}); |
| try { |
| computePassEncoder90.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup21, new Uint32Array(481), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer42, 88); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer6, 'uint32', 524, 196); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 180, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture87, |
| mipLevel: 3, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let video2 = await videoWithData(100); |
| let bindGroup69 = device0.createBindGroup({ |
| label: '\u9eb1\u09f0\ua8d7\u{1fc4a}', |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 15, resource: {buffer: buffer6, offset: 768, size: 252}}, |
| {binding: 0, resource: textureView3}, |
| ], |
| }); |
| let buffer70 = device0.createBuffer({ |
| size: 3258, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let renderPassEncoder24 = commandEncoder120.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView86, |
| clearValue: { r: 872.4, g: 748.2, b: -190.8, a: 835.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup64, new Uint32Array(210), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(1_414, 11, 628, 80_386_762, 249_638_281); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer42, 20); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let commandEncoder121 = device0.createCommandEncoder(); |
| let texture122 = device0.createTexture({ |
| label: '\uf9ca\u{1fb4f}\u0df4\u{1f6a2}\u0a9e\u0ee7\uea94\u6290\u{1f8ec}\u{1f983}', |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView93 = texture121.createView({label: '\ufb15\uba73\ub716', dimension: '1d'}); |
| try { |
| computePassEncoder92.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle9, renderBundle0, renderBundle0, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(46, 1, 1_509_679_870, 1_071_994_285); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(256, 60, 1_583, 726_070_579, 2_609_773_941); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer8, 'uint32', 1_536, 208); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer71 = device0.createBuffer({ |
| size: 13563, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder93 = commandEncoder118.beginComputePass(); |
| let renderPassEncoder25 = commandEncoder119.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView86, |
| clearValue: { r: -890.7, g: 110.5, b: 996.9, a: -142.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 122390179, |
| }); |
| let sampler67 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 3.609, |
| lodMaxClamp: 72.35, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder93.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup7, new Uint32Array(814), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(374, 206, 0, 142_534_684, 126_047_489); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer6, 'uint32', 1_120, 1_028); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer70); |
| } catch {} |
| try { |
| commandEncoder121.copyTextureToTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 9, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData19 = new ImageData(4, 56); |
| let pipelineLayout11 = device0.createPipelineLayout({label: '\uc03b\ued06\u522b\u8836\ufc36\u80bb\u{1f6e8}\ud1c3\u0ab5\u{1f953}', bindGroupLayouts: []}); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let renderPassEncoder26 = commandEncoder121.beginRenderPass({ |
| label: '\u6e49\u{1f904}\u{1fbce}\u{1fa40}\u0fbe\u0f5e\u{1f9e4}\ud1f0\u01cc\ub174\u{1ffcc}', |
| colorAttachments: [{ |
| view: textureView82, |
| depthSlice: 120, |
| clearValue: { r: -349.4, g: 379.4, b: -37.37, a: -53.50, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder89.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle9, renderBundle0]); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: bindGroupLayout10, |
| entries: [ |
| {binding: 83, resource: {buffer: buffer9, offset: 1024, size: 1092}}, |
| {binding: 130, resource: {buffer: buffer58, offset: 0, size: 416}}, |
| {binding: 335, resource: textureView11}, |
| {binding: 633, resource: textureView89}, |
| {binding: 80, resource: textureView74}, |
| {binding: 3, resource: textureView80}, |
| {binding: 169, resource: textureView88}, |
| {binding: 41, resource: textureView89}, |
| {binding: 444, resource: textureView6}, |
| {binding: 78, resource: textureView70}, |
| {binding: 139, resource: textureView63}, |
| ], |
| }); |
| let commandEncoder123 = device0.createCommandEncoder(); |
| let texture123 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 100}, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder82.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup27, new Uint32Array(1797), 397, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 236, 0, 129_870_040, 1_056_486_642); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer57, 160); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer60, 276); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer20, 'uint32', 144, 447); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let shaderModule11 = device0.createShaderModule({ |
| label: '\u0534\u8c91\u{1f88d}\u{1fc82}\u3b6d', |
| code: ` |
| enable f16; |
| /* target size: 6 max align: 2 */ |
| struct T0 { |
| @align(2) @size(6) f0: array<u32, 1>, |
| } |
| @group(0) @binding(234) var sam4: sampler; |
| @group(0) @binding(49) var st26: texture_storage_2d_array<r32float, write>; |
| @group(0) @binding(374) var st27: texture_storage_2d<rgba8unorm, read>; |
| @group(0) @binding(15) var tex4: texture_depth_cube_array; |
| struct FragmentOutput11 { |
| @location(0) f0: vec4f, |
| @location(5) @interpolate(flat) f1: vec2i |
| } |
| |
| @fragment |
| fn fragment0(@location(15) @interpolate(flat, centroid) a0: vec4u) -> FragmentOutput11 { |
| var out: FragmentOutput11; |
| textureStore(st26, vec2i(), 0, vec4f(0.07372, 0.1111, 0.2320, 0.08167)); |
| return out; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer72 = device0.createBuffer({ |
| size: 520, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let querySet16 = device0.createQuerySet({type: 'occlusion', count: 349}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true}); |
| try { |
| computePassEncoder77.setBindGroup(3, bindGroup43, new Uint32Array(2331), 1_220, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup56); |
| } catch {} |
| try { |
| renderPassEncoder4.setViewport(1.2802783393089365, 0.2172001669305097, 0.4051008463841231, 0.5983344076192693, 0.043960291335062185, 0.3388815613823228); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(1_953, 195, 85, 173_152_461, 1_476_732_809); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer26, 88); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer70, 412); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(6, buffer30, 6_464, 3_451); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup8, new Uint32Array(2967), 841, 0); |
| } catch {} |
| try { |
| commandEncoder122.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 742 */ |
| offset: 742, |
| buffer: buffer18, |
| }, { |
| texture: texture105, |
| mipLevel: 0, |
| origin: {x: 119, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder123.resolveQuerySet(querySet4, 1, 17, buffer11, 2560); |
| } catch {} |
| let buffer73 = device0.createBuffer({ |
| size: 30585, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundle15 = renderBundleEncoder15.finish(); |
| try { |
| computePassEncoder83.setBindGroup(3, bindGroup10, new Uint32Array(3280), 356, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup67, new Uint32Array(67), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 22, 0, 333_638_313, 568_752_642); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer53, 116); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline9); |
| } catch {} |
| document.body.append(video2); |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let texture124 = device0.createTexture({ |
| size: {width: 600, height: 96, depthOrArrayLayers: 121}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let renderPassEncoder27 = commandEncoder122.beginRenderPass({colorAttachments: [{view: textureView48, depthSlice: 13, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer42, 44); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(5, buffer30, 6_172, 3_332); |
| } catch {} |
| try { |
| commandEncoder123.copyTextureToBuffer({ |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 172, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 108 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3612 */ |
| offset: 3612, |
| buffer: buffer73, |
| }, {width: 27, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 168, resource: sampler6}, |
| {binding: 589, resource: {buffer: buffer41, offset: 768, size: 411}}, |
| {binding: 19, resource: textureView27}, |
| ], |
| }); |
| let querySet17 = device0.createQuerySet({type: 'occlusion', count: 132}); |
| let computePassEncoder94 = commandEncoder123.beginComputePass({label: '\u7311\u20a2\uad98\u839b\u0ec2\ue5b2\uaccc\uddac\uebd9\u{1fbd0}'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup28, new Uint32Array(343), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(19, 131, 1_083_235_861, 138_228_937); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 11, 0, -1_956_601_266, 222_100_604); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder124.resolveQuerySet(querySet5, 9, 55, buffer56, 12288); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let textureView94 = texture32.createView({}); |
| try { |
| computePassEncoder65.setBindGroup(3, bindGroup38, []); |
| } catch {} |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup8, new Uint32Array(1641), 597, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle1, renderBundle9, renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setViewport(0.8791538774222274, 0.3738124642944425, 0.7646714922508838, 1.4109775599523702, 0.8511685667847928, 0.9713743832702074); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 33, 0, 400_784_412, 377_537_159); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer38, 388); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer60, 420); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(2, buffer39, 1_148, 800); |
| } catch {} |
| let arrayBuffer6 = buffer54.getMappedRange(0, 88); |
| let bindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 92, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 73, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer74 = device0.createBuffer({size: 29749, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView95 = texture118.createView({}); |
| let sampler68 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 71.33, |
| lodMaxClamp: 98.33, |
| }); |
| try { |
| computePassEncoder91.setBindGroup(3, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(59, 11, 1_677_179_220, 1_004_205_926); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 262, 0, -1_881_764_603, 989_755_587); |
| } catch {} |
| try { |
| computePassEncoder14.pushDebugGroup('\u47ee'); |
| } catch {} |
| await gc(); |
| let textureView96 = texture107.createView({label: '\u4b57\u{1fbec}\u{1ffc8}\u10c4\u93ea\u3c1a\u0ee4\u{1fa4a}\u0715\u{1fb10}\ub0ad'}); |
| let texture125 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| renderPassEncoder4.drawIndexed(69, 457, 185, -1_885_366_790, 3_386_248_462); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer53, 228); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 69, y: 6, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(368).fill(118), /* required buffer size: 368 */ |
| {offset: 368, bytesPerRow: 141}, {width: 13, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(video0); |
| let texture126 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 571}, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture127 = device0.createTexture({ |
| size: [2], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let textureView97 = texture54.createView({mipLevelCount: 1}); |
| let sampler69 = device0.createSampler({ |
| label: '\u{1f981}\u{1fbe2}', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 10.30, |
| lodMaxClamp: 16.80, |
| compare: 'less-equal', |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder49.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder23.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(243, 192, 429_574_488, 543_941_754); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(109, 115, 1_417, -2_113_968_793, 2_436_737_344); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer15, 468); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer40, 336); |
| } catch {} |
| let arrayBuffer7 = buffer66.getMappedRange(6888, 412); |
| try { |
| commandEncoder125.copyTextureToBuffer({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 56, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 184 widthInBlocks: 46 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 816 */ |
| offset: 816, |
| rowsPerImage: 309, |
| buffer: buffer51, |
| }, {width: 46, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData20 = new ImageData(16, 36); |
| try { |
| device0.label = '\u28b3\u{1fa06}\u01f7\u7c75\uc768'; |
| } catch {} |
| let texture128 = device0.createTexture({ |
| size: {width: 300, height: 48, depthOrArrayLayers: 61}, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture129 = device0.createTexture({ |
| label: '\u6754\u0ccc\u199b', |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder28 = commandEncoder124.beginRenderPass({ |
| label: '\u2629\u7fcc\u{1f998}\u{1f9c4}\u9337\u0b3c\ub41a\ue10c\u64ac\u{1fa55}\u0e8b', |
| colorAttachments: [{view: textureView86, loadOp: 'clear', storeOp: 'store'}], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer50, 140); }; |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(847, 127, 561, 231_028_172, 1_633_578_548); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer67, 'uint16', 4_040, 2_184); |
| } catch {} |
| let textureView98 = texture126.createView({}); |
| let texture130 = device0.createTexture({ |
| size: [164, 12, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView99 = texture100.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder95 = commandEncoder125.beginComputePass({label: '\u{1fcd4}\u3608\u4c39\u1acb\u059f\u{1fa99}\u0925'}); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup4, new Uint32Array(5471), 153, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 182, 0, -1_656_967_339, 636_326_159); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer27, 'uint32', 136, 141); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer75 = device0.createBuffer({ |
| label: '\ucff9\u074f\u{1fbf8}\u{1fe54}\u{1f821}', |
| size: 31757, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView100 = texture110.createView({label: '\u{1ff43}\u0a33', aspect: 'all', baseMipLevel: 0}); |
| let textureView101 = texture109.createView({format: 'rg32sint'}); |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup65); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup42, new Uint32Array(229), 32, 0); |
| } catch {} |
| try { |
| computePassEncoder95.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(217, 214, 407_990_977, 246_098_365); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer60, 120); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 9} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 1, y: 22 }, |
| flipY: true, |
| }, { |
| texture: texture42, |
| mipLevel: 2, |
| origin: {x: 25, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup72 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 90, resource: textureView20}]}); |
| let buffer76 = device0.createBuffer({ |
| size: 3475, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView102 = texture84.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder63.setBindGroup(1, bindGroup57); |
| } catch {} |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup52, new Uint32Array(263), 28, 0); |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup50, new Uint32Array(956), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer53, 'uint16', 70, 93); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer44.unmap(); |
| } catch {} |
| try { |
| computePassEncoder6.pushDebugGroup('\u0e96'); |
| } catch {} |
| await gc(); |
| try { |
| renderPassEncoder14.setViewport(1445.1315237228443, 0.6676021042479752, 283.0562992466295, 1.3891220165892584, 0.0584104210095886, 0.4948134819778847); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(16, 381, 378, 191_567_853, 154_319_195); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer42, 24); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer1, 'uint32', 14_900, 7_519); |
| } catch {} |
| try { |
| buffer72.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| let commandEncoder126 = device0.createCommandEncoder({}); |
| let textureView103 = texture128.createView({format: 'rg32sint'}); |
| let texture131 = device0.createTexture({ |
| label: '\u40e0\u{1fc0a}\u0d44\ua48a\u0014\u567e\u85e3\u{1fb77}\u{1fa1f}', |
| size: [164, 12, 1], |
| mipLevelCount: 1, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder8.draw(52, 407, 116_988_265, 218_140_534); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder63.setBindGroup(0, bindGroup44); |
| } catch {} |
| try { |
| computePassEncoder86.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(36, 236, 2_910_969_552, 1_467_841_696); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(5, 13, 11, -456_759_542, 747_901_765); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer33, 4_188); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer6, 'uint16', 804, 54); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer33, 0, 954); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer58, 5672, new Int16Array(18117), 823, 1064); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture116, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(346).fill(106), /* required buffer size: 346 */ |
| {offset: 346, rowsPerImage: 107}, {width: 26, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext4 = canvas2.getContext('webgpu'); |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder53.setBindGroup(0, bindGroup29, new Uint32Array(5352), 889, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup11, new Uint32Array(2930), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(29, 477, 1_366_554_594, 109_220_196); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer63, 2_036); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(1, buffer55, 0, 2_718); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture122, |
| mipLevel: 0, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(90).fill(79), /* required buffer size: 90 */ |
| {offset: 90, bytesPerRow: 178}, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({ |
| layout: bindGroupLayout15, |
| entries: [{binding: 92, resource: {buffer: buffer19, offset: 2048, size: 808}}], |
| }); |
| let buffer77 = device0.createBuffer({ |
| size: 24288, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let texture132 = device0.createTexture({ |
| size: [2880, 4, 1], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView104 = texture71.createView({}); |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup63, new Uint32Array(1218), 364, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.executeBundles([renderBundle2, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(122, 38, 323_635_278, 792_595_094); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 228, 0, 1_077_052_319, 135_966_353); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 244); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder85.setBindGroup(0, bindGroup73, new Uint32Array(1698), 412, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(596, 342, 84, -2_034_698_129, 733_744_821); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer15, 1_076); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer33, 4_612); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer4, 'uint32', 876, 4_286); |
| } catch {} |
| try { |
| renderPassEncoder26.insertDebugMarker('\u61ec'); |
| } catch {} |
| let imageData21 = new ImageData(8, 24); |
| let texture133 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView105 = texture103.createView({dimension: 'cube'}); |
| let sampler70 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 17, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup56); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(230, 255, 223_784_963, 37_426_227); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 35, 0, 52_286_085, 98_748_380); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer66, 644); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 365, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(6).fill(249), /* required buffer size: 6 */ |
| {offset: 6}, {width: 41, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| let commandBuffer5 = commandEncoder127.finish(); |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(175, 32, 1_881_100_084, 1_620_808_262); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer70, 60); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer41, 708); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| texture39.destroy(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 248, new Float32Array(21056), 126, 68); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1440, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video1, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture69, |
| mipLevel: 1, |
| origin: {x: 33, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 92, resource: {buffer: buffer64, offset: 0}}]}); |
| let buffer78 = device0.createBuffer({size: 16304, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, mappedAtCreation: true}); |
| let commandEncoder132 = device0.createCommandEncoder(); |
| let textureView106 = texture84.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let computePassEncoder96 = commandEncoder132.beginComputePass({}); |
| try { |
| computePassEncoder96.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(398, 29, 406_154_979, 161_319_666); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(681, 17, 435, -2_122_493_170, 409_256_956); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer51, 6_196); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| let textureView107 = texture49.createView({dimension: '1d', mipLevelCount: 1}); |
| let computePassEncoder97 = commandEncoder129.beginComputePass({label: '\u6b6f\u085a\u75f8'}); |
| try { |
| computePassEncoder37.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(0, bindGroup26, new Uint32Array(4051), 175, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(251, 155, 52_606_038, 326_460_942); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer67, 928); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer38, 332); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer58, 1_736, 2_744); |
| } catch {} |
| let videoFrame16 = new VideoFrame(img0, {timestamp: 0}); |
| let textureView108 = texture118.createView({label: '\u522b\u660b\u{1f82b}', format: 'rgba32sint', mipLevelCount: 1}); |
| let renderPassEncoder29 = commandEncoder126.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 236, |
| clearValue: { r: -60.58, g: -832.9, b: 971.5, a: -3.134, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet11, |
| }); |
| try { |
| computePassEncoder97.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(3, bindGroup15, new Uint32Array(248), 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(189, 45, 720, 518_045_508, 342_000_041); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer30, 6_792); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let bindGroup75 = device0.createBindGroup({ |
| layout: bindGroupLayout12, |
| entries: [ |
| {binding: 17, resource: {buffer: buffer73, offset: 2048, size: 2325}}, |
| {binding: 380, resource: textureView74}, |
| ], |
| }); |
| let commandEncoder133 = device0.createCommandEncoder({label: '\u{1ff9a}\ufefe\ue313\u01a1\uea53\u0798\u0299\ue4b5\u8475\u{1fbd3}\u17ed'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(297, 414, 790_738_008, 268_872_069); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer76, 152, new Float32Array(12062), 287, 56); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture127, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(32).fill(196), /* required buffer size: 32 */ |
| {offset: 32, bytesPerRow: 34}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 148} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 19, y: 35 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 13}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt709', transfer: 'smpteSt4281'} }); |
| try { |
| adapter0.label = '\u3be5\ud917\u1a88'; |
| } catch {} |
| let shaderModule12 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 4 max align: 4 */ |
| struct T0 { |
| f0: vec2h, |
| } |
| /* target size: 51 max align: 1 */ |
| struct T1 { |
| @align(1) @size(32) f0: mat3x3h, |
| @align(1) @size(8) f1: atomic<i32>, |
| @align(1) @size(11) f2: array<atomic<u32>>, |
| } |
| /* target size: 122 max align: 2 */ |
| struct T2 { |
| @align(2) @size(8) f0: T0, |
| @size(16) f1: f16, |
| @align(2) @size(28) f2: array<T0, 1>, |
| @align(2) f3: T0, |
| @align(2) @size(16) f4: T0, |
| @align(2) f5: u32, |
| @align(2) f6: array<f32, 4>, |
| @align(1) @size(30) f7: T0, |
| } |
| /* target size: 51 max align: 1 */ |
| struct T3 { |
| @align(1) @size(51) f0: array<array<T0, 1>>, |
| } |
| @group(0) @binding(15) var tex5: texture_cube_array<i32>; |
| @group(0) @binding(49) var st28: texture_storage_1d<r32sint, write>; |
| @group(1) @binding(64) var<storage, read_write> buffer79: T3; |
| @group(0) @binding(234) var sam5: sampler; |
| @group(0) @binding(374) var st29: texture_storage_1d<rgba32float, read>; |
| struct VertexOutput11 { |
| @builtin(position) f36: vec4f |
| } |
| |
| @vertex |
| fn vertex0(@builtin(vertex_index) a0: u32) -> VertexOutput11 { |
| var out: VertexOutput11; |
| _ = textureGather(0, tex5, sam5, vec3f(), 0); |
| if bool(textureGather(1, tex5, sam5, vec3f(), 0)[3]) { |
| var v: vec4f; |
| } |
| return out; |
| } |
| struct VertexOutput12 { |
| @location(7) f37: vec2i, |
| @location(3) @interpolate(flat, sample) f38: u32, |
| @builtin(position) f39: vec4f |
| } |
| |
| @vertex |
| fn vertex1(@location(11) a0: vec2f, @location(4) a1: i32) -> VertexOutput12 { |
| var out: VertexOutput12; |
| return out; |
| } |
| struct S3 { |
| @location(6) @interpolate(linear, centroid) f0: vec2h |
| } |
| struct S4 { |
| @location(15) @interpolate(flat, center) f0: vec2i, |
| @location(1) @interpolate(flat) f1: u32 |
| } |
| struct FragmentOutput12 { |
| @location(0) @interpolate(flat) f0: vec4f |
| } |
| |
| @fragment |
| fn fragment0(a0: S3, @location(11) a1: f16, @location(12) a2: vec2i, a3: S4, @builtin(position) a4: vec4f) -> FragmentOutput12 { |
| var out: FragmentOutput12; |
| _ = a4; |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| _ = buffer79.f0[arrayLength(&buffer79.f0) - 1]; |
| _ = buffer79.f0; |
| _ = arrayLength(&buffer79.f0); |
| textureStore(st28, 0, vec4i(146, 15, 298, 22)); |
| }`, |
| hints: {}, |
| }); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let texture134 = device0.createTexture({ |
| size: [1554, 65, 1], |
| format: 'astc-6x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder98 = commandEncoder130.beginComputePass({}); |
| try { |
| computePassEncoder98.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup30, new Uint32Array(3284), 555, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer17, 680); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline7); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| try { |
| computePassEncoder6.popDebugGroup(); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup39); |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline4); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let bindGroupLayout17 = device0.createBindGroupLayout({ |
| label: '\uf042\u{1fa8d}\u8df4\u2243\u06f1\u8035', |
| entries: [ |
| { |
| binding: 67, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let texture135 = device0.createTexture({ |
| size: {width: 150}, |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler71 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 64.98, |
| lodMaxClamp: 94.17, |
| }); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(6, 177, 1_061_833_129, 127_634_741); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(542, 783, 421, 641_987_310, 1_301_371_120); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer42, 16); |
| } catch {} |
| try { |
| commandEncoder133.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3504 */ |
| offset: 3504, |
| rowsPerImage: 715, |
| buffer: buffer30, |
| }, { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'jedecP22Phosphors', transfer: 'iec6196624'} }); |
| let buffer80 = device0.createBuffer({ |
| label: '\u1862\ub943\u{1ffc4}\u66c1', |
| size: 2829, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture136 = device0.createTexture({ |
| label: '\u{1ffeb}\u1ff2', |
| size: [360], |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder99 = commandEncoder128.beginComputePass({}); |
| try { |
| computePassEncoder99.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup20, new Uint32Array(4111), 1_716, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer72, 48); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer42, 20); |
| } catch {} |
| let promise14 = shaderModule2.getCompilationInfo(); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let imageData22 = new ImageData(4, 32); |
| let bindGroup76 = device0.createBindGroup({ |
| layout: bindGroupLayout12, |
| entries: [ |
| {binding: 380, resource: textureView74}, |
| {binding: 17, resource: {buffer: buffer80, offset: 0, size: 861}}, |
| ], |
| }); |
| let buffer81 = device0.createBuffer({size: 1938, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let textureView109 = texture136.createView({}); |
| let texture137 = device0.createTexture({ |
| size: [75, 12, 1], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler72 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 15.21, |
| }); |
| try { |
| renderPassEncoder18.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(9, 3, 79, 80_418_323, 725_321_577); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture105, |
| mipLevel: 0, |
| origin: {x: 162, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(286).fill(118), /* required buffer size: 286 */ |
| {offset: 286, rowsPerImage: 0}, {width: 62, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer72, 52); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer42, 'uint32', 68, 52); |
| } catch {} |
| try { |
| buffer70.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder136 = device0.createCommandEncoder(); |
| let textureView110 = texture95.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let sampler73 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 82.67, |
| lodMaxClamp: 93.07, |
| }); |
| try { |
| computePassEncoder69.setBindGroup(0, bindGroup19, new Uint32Array(103), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer56, 968); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer17, 16); |
| } catch {} |
| try { |
| await shaderModule10.getCompilationInfo(); |
| } catch {} |
| let bindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 135, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture138 = device0.createTexture({ |
| size: {width: 82, height: 6, depthOrArrayLayers: 1316}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture139 = device0.createTexture({ |
| label: '\ue87e\u{1f99b}', |
| size: {width: 75, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView111 = texture35.createView({format: 'rgb10a2unorm', arrayLayerCount: 1}); |
| try { |
| computePassEncoder61.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup19, []); |
| } catch {} |
| try { |
| renderPassEncoder8.setViewport(1.0779061027219623, 1.169835326061518, 0.1529145368206669, 0.4365369316992639, 0.40770078509216146, 0.8499519649698997); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexed(10, 382, 90, 173_383_686, 489_299_257); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer49, 'uint16', 12_810, 7_062); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer68, 192, 16); |
| } catch {} |
| let buffer82 = device0.createBuffer({ |
| label: '\uc0b0\u03e9\u48e8\u0d14\u{1fd97}\u5d5c\u{1f6a1}\u{1fab9}', |
| size: 2924, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView112 = texture138.createView({aspect: 'all'}); |
| let texture140 = device0.createTexture({ |
| size: [300, 48, 403], |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView113 = texture103.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 6}); |
| try { |
| computePassEncoder87.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup7, new Uint32Array(327), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer45, 2_704); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(1, buffer47, 68, 1); |
| } catch {} |
| try { |
| computePassEncoder61.pushDebugGroup('\ub049'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 344, new Int16Array(11747), 405, 96); |
| } catch {} |
| video0.width = 22; |
| let imageData23 = new ImageData(24, 92); |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| let computePassEncoder100 = commandEncoder131.beginComputePass({}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder100.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup18, new Uint32Array(2581), 58, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 472, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer83 = device0.createBuffer({size: 9812, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView114 = texture61.createView({dimension: '2d-array', format: 'r32uint'}); |
| let sampler74 = device0.createSampler({ |
| label: '\u0cf5\u5b14', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 5.682, |
| lodMaxClamp: 19.57, |
| compare: 'never', |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder80.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer33, 1_164); }; |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer72, 36); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer26, 512); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer8, 'uint16', 22, 74); |
| } catch {} |
| let texture141 = device0.createTexture({ |
| size: {width: 164}, |
| dimension: '1d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder3.drawIndexed(419, 13, 138, 49_734_772, 1_649_023_994); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer33, 'uint32', 5_956, 4_150); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder35.pushDebugGroup('\u7f80'); |
| } catch {} |
| let bindGroup77 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [{binding: 28, resource: {buffer: buffer65, offset: 1792, size: 92}}], |
| }); |
| let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer84 = device0.createBuffer({label: '\ue818\u03fe\u{1f650}\ucce3\u{1f692}', size: 6225, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder138 = device0.createCommandEncoder(); |
| let textureView115 = texture85.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let computePassEncoder101 = commandEncoder137.beginComputePass(); |
| try { |
| computePassEncoder101.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer56, 3_732); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 148} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| video1.requestVideoFrameCallback((now, metadata) => { metadata.length = now; }); |
| let shaderModule13 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 54 max align: 2 */ |
| struct T0 { |
| @align(2) f0: vec2h, |
| @align(2) @size(8) f1: atomic<u32>, |
| @align(2) @size(42) f2: mat2x3f, |
| } |
| /* target size: 54 max align: 2 */ |
| struct T1 { |
| @align(2) f0: atomic<i32>, |
| @align(1) @size(50) f1: array<atomic<i32>>, |
| } |
| @group(0) @binding(28) var<storage, read_write> buffer85: T0; |
| struct VertexOutput13 { |
| @location(7) @interpolate(perspective) f40: vec4h, |
| @location(4) f41: vec3h, |
| @builtin(position) f42: vec4f, |
| @location(10) f43: f16, |
| @location(8) @interpolate(flat, centroid) f44: vec4i |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput13 { |
| var out: VertexOutput13; |
| return out; |
| } |
| struct FragmentOutput13 { |
| @location(0) f0: vec4f |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput13 { |
| var out: FragmentOutput13; |
| _ = buffer85.f0; |
| _ = buffer85.f2; |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 2, 1) |
| fn compute0() { |
| }`, |
| hints: {}, |
| }); |
| let bindGroup78 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView13}]}); |
| let pipelineLayout15 = device0.createPipelineLayout({label: '\u0b2d\u{1fbaa}\u0d93\u{1f91d}\ua4c4', bindGroupLayouts: []}); |
| let textureView116 = texture11.createView({format: 'rgb10a2unorm'}); |
| let computePassEncoder102 = commandEncoder138.beginComputePass({}); |
| let renderPassEncoder30 = commandEncoder133.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView48, |
| depthSlice: 2, |
| clearValue: { r: 393.3, g: 375.0, b: 683.3, a: 839.5, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 125943185, |
| }); |
| let sampler75 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 50.96, |
| lodMaxClamp: 51.37, |
| }); |
| try { |
| computePassEncoder49.setBindGroup(0, bindGroup74, new Uint32Array(3921), 195, 0); |
| } catch {} |
| try { |
| computePassEncoder102.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup42, new Uint32Array(6320), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.beginOcclusionQuery(505); |
| } catch {} |
| try { |
| renderPassEncoder7.setViewport(1.7737957443695223, 1.6111215268549464, 0.09490738803793344, 0.3187580173717878, 0.12624666104280347, 0.6914166671197826); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer72, 48); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer65, 676); |
| } catch {} |
| try { |
| commandEncoder136.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture15, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 10}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'r16sint']}); |
| try { |
| renderPassEncoder29.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder134.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 7, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer69, 344, new BigUint64Array(8011), 468, 696); |
| } catch {} |
| try { |
| computePassEncoder84.setBindGroup(2, bindGroup20, new Uint32Array(2900), 2_224, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer38, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(92, 160, 1_455_298_044, 118_612_976); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(25, 305, 81, 193_457_151, 87_266_411); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer33, 204); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer13, 'uint16', 3_680, 2_044); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup17, new Uint32Array(4354), 1_057, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer59, 'uint16', 260, 596); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(4, buffer35, 0); |
| } catch {} |
| document.body.prepend(img2); |
| let textureView117 = texture91.createView({}); |
| let computePassEncoder103 = commandEncoder136.beginComputePass({}); |
| let renderBundle16 = renderBundleEncoder16.finish({}); |
| let sampler76 = device0.createSampler({ |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 18.47, |
| lodMaxClamp: 46.25, |
| compare: 'less', |
| maxAnisotropy: 7, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer57, 420); }; |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(42, 118, 1_325_558_112, 501_175_962); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer15, 40); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline9); |
| } catch {} |
| try { |
| texture63.destroy(); |
| } catch {} |
| try { |
| buffer21.unmap(); |
| } catch {} |
| try { |
| computePassEncoder14.popDebugGroup(); |
| } catch {} |
| let texture142 = device0.createTexture({ |
| size: [164], |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba32float', 'rgba32float'], |
| }); |
| let computePassEncoder104 = commandEncoder134.beginComputePass({}); |
| let renderPassEncoder31 = commandEncoder135.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView12, |
| depthSlice: 212, |
| clearValue: { r: -9.697, g: -398.2, b: -934.8, a: -31.50, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler77 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 76.10, |
| lodMaxClamp: 87.07, |
| compare: 'greater-equal', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer50, 612); }; |
| } catch {} |
| try { |
| computePassEncoder104.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(87, 83, 139_319_022, 348_742_876); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 185, 0, 169_423_459, 940_091_670); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer21, 'uint16', 306, 198); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer68); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas2); |
| let buffer86 = device0.createBuffer({ |
| size: 14151, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture143 = device0.createTexture({ |
| size: {width: 720, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder103.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(35); |
| } catch {} |
| try { |
| renderPassEncoder14.setScissorRect(246, 0, 512, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer21, 8); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer53, 'uint16', 36, 329); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(1, buffer71, 0, 2_052); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| let bindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 189, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 252, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let querySet18 = device0.createQuerySet({type: 'occlusion', count: 685}); |
| let textureView118 = texture28.createView({dimension: '2d-array'}); |
| let textureView119 = texture14.createView({label: '\u7a0f\u03bf\u0b54\u7854\ua4d4\u3db6', dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup6, new Uint32Array(3121), 712, 0); |
| } catch {} |
| try { |
| computePassEncoder56.dispatchWorkgroups(1); |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup67, new Uint32Array(282), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(9, 126, 123_709_837, 354_246_138); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer65, 120); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer33, 1_296); |
| } catch {} |
| let buffer87 = device0.createBuffer({size: 10035, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture144 = device0.createTexture({ |
| size: {width: 329, height: 24, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView120 = texture42.createView({baseMipLevel: 2, mipLevelCount: 1}); |
| try { |
| computePassEncoder86.setBindGroup(1, bindGroup55); |
| } catch {} |
| try { |
| computePassEncoder75.setBindGroup(3, bindGroup35, new Uint32Array(2413), 300, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup19, new Uint32Array(742), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(232, 12, 893_071_186, 661_663_991); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer15, 2_832); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer42, 'uint16', 46, 7); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(7, buffer60); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 0, y: 9 }, |
| flipY: false, |
| }, { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder139 = device0.createCommandEncoder(); |
| let computePassEncoder105 = commandEncoder139.beginComputePass({}); |
| try { |
| computePassEncoder105.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup77); |
| } catch {} |
| try { |
| renderPassEncoder29.beginOcclusionQuery(127); |
| } catch {} |
| try { |
| renderPassEncoder29.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(509, 11, 326_358_817, 1_074_467_401); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer72, 88); |
| } catch {} |
| let bindGroup79 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView1}]}); |
| try { |
| renderPassEncoder28.setBindGroup(3, bindGroup68, []); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer42, 56, 14); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpte432', transfer: 'gamma22curve'} }); |
| let bindGroup80 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView24}]}); |
| let buffer88 = device0.createBuffer({size: 21, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let sampler78 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 27.39, |
| lodMaxClamp: 84.71, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup57, new Uint32Array(887), 0, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer53, 28); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setViewport(0.3160767874353765, 0.2597295085809763, 1.5121205580154022, 1.1470037081481035, 0.5063282461349343, 0.857429814032075); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(100, 754, 3, 751_768, 302_941_378); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer40, 8); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(2, buffer75, 0, 815); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| let textureView121 = texture78.createView({dimension: '2d', mipLevelCount: 1}); |
| let texture145 = device0.createTexture({ |
| label: '\uaf43\uc355', |
| size: {width: 300, height: 48, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder106 = commandEncoder140.beginComputePass({label: '\u05ee\u6560\u84e5\u4384\u{1f8d7}\uaab1\u0f67\u0da4\ue941'}); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgba32sint', 'r16sint'], depthReadOnly: true}); |
| let renderBundle17 = renderBundleEncoder17.finish({}); |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 26, 0, 528_129_527, 195_017_778); |
| } catch {} |
| let arrayBuffer8 = buffer61.getMappedRange(7824, 804); |
| try { |
| device0.queue.writeBuffer(buffer29, 3860, new DataView(new ArrayBuffer(11985)), 2540, 648); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let video3 = await videoWithData(19); |
| let bindGroup81 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 135, resource: textureView112}]}); |
| let texture146 = device0.createTexture({ |
| label: '\ub3b9\u6c47\u59ec\u1825\u{1f672}', |
| size: [659], |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture147 = device0.createTexture({ |
| label: '\u0449\u50da\u9732\u{1ff9b}\u{1f60d}\u8ccc\u2ee9\u{1fb5a}\u0b1c\u555d\u776f', |
| size: {width: 1440, height: 2, depthOrArrayLayers: 1}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(2, 2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(18, 104, 59, 742_971_838, 1_548_273_296); |
| } catch {} |
| let arrayBuffer9 = buffer54.getMappedRange(88, 768); |
| let buffer89 = device0.createBuffer({ |
| size: 1737, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let computePassEncoder107 = commandEncoder141.beginComputePass({}); |
| let sampler79 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 46.95, |
| lodMaxClamp: 74.77, |
| maxAnisotropy: 4, |
| }); |
| let externalTexture12 = device0.importExternalTexture({source: video2}); |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer59, 'uint32', 64, 8); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({layout: bindGroupLayout17, entries: [{binding: 67, resource: textureView109}]}); |
| let commandEncoder142 = device0.createCommandEncoder({}); |
| let textureView122 = texture104.createView({}); |
| let computePassEncoder108 = commandEncoder142.beginComputePass({}); |
| try { |
| renderPassEncoder8.drawIndexed(12, 99, 90, -1_970_644_918, 106_047_425); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer82, 1_600); |
| } catch {} |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| let texture148 = device0.createTexture({ |
| size: {width: 1440, height: 2, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup44, new Uint32Array(1607), 380, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(743, 21, 10, 163_683_061, 804_345_066); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer73, 0); |
| } catch {} |
| try { |
| commandEncoder143.copyBufferToTexture({ |
| /* bytesInLastRow: 508 widthInBlocks: 127 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 328 */ |
| offset: 328, |
| bytesPerRow: 512, |
| buffer: buffer33, |
| }, { |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 114, y: 26, z: 0}, |
| aspect: 'all', |
| }, {width: 127, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder143.resolveQuerySet(querySet3, 4, 3, buffer24, 3328); |
| } catch {} |
| try { |
| computePassEncoder41.insertDebugMarker('\u05c7'); |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({layout: bindGroupLayout13, entries: [{binding: 168, resource: textureView74}]}); |
| let renderPassEncoder32 = commandEncoder143.beginRenderPass({colorAttachments: [{view: textureView115, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer50, 1_848); }; |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer38, 492); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup28, new Uint32Array(776), 379, 0); |
| } catch {} |
| try { |
| computePassEncoder106.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer8, 'uint16', 1_852, 353); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer58, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| document.body.prepend(img2); |
| video2.height = 35; |
| await gc(); |
| try { |
| computePassEncoder43.setBindGroup(1, bindGroup28, new Uint32Array(983), 273, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline10); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder29.beginOcclusionQuery(90); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle0, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer26, 616); |
| } catch {} |
| try { |
| computePassEncoder80.insertDebugMarker('\u024e'); |
| } catch {} |
| let img3 = await imageWithData(29, 64, '#10101010', '#20202020'); |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let texture149 = device0.createTexture({ |
| size: [300], |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView123 = texture146.createView({label: '\uf44d\ua146\u08b6\u0545\u{1fa5d}\u{1f74f}\u{1ff6d}\u97c0\u8582\u0dde'}); |
| let computePassEncoder109 = commandEncoder144.beginComputePass({label: '\uacca\u{1fbce}\u47b2\u0b99\u72ca\u046b\uc217'}); |
| try { |
| computePassEncoder44.setBindGroup(3, bindGroup61); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer52, 952); }; |
| } catch {} |
| try { |
| computePassEncoder107.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup3, new Uint32Array(2255), 822, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setBlendConstant({ r: -275.8, g: -863.7, b: -304.7, a: -602.6, }); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(122, 15, 274_924_079, 542_971_167); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let renderPassEncoder33 = commandEncoder145.beginRenderPass({ |
| label: '\u0027\uf6c1\u25db', |
| colorAttachments: [{view: textureView85, depthSlice: 7, loadOp: 'load', storeOp: 'discard'}], |
| occlusionQuerySet: querySet3, |
| maxDrawCount: 344133529, |
| }); |
| let sampler80 = device0.createSampler({ |
| label: '\u0033\uc3e1\uead0\u0f0b\u{1f67a}\u2416\u6234\u01fa\u67de\ud9b4', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 79.00, |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup5, []); |
| } catch {} |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup32, new Uint32Array(4729), 1_500, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder29.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 141, 0, 917_030_332, 2_610_014_906); |
| } catch {} |
| try { |
| renderPassEncoder3.insertDebugMarker('\u5d50'); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let buffer90 = device0.createBuffer({size: 2559, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture150 = device0.createTexture({ |
| label: '\u057d\u80b2\u1a6c\u{1fd09}\u{1f7d4}\u8d56\u7941\u0cff\u0503\ube79\u608c', |
| size: {width: 600, height: 96, depthOrArrayLayers: 50}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView124 = texture46.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer67, 308); }; |
| } catch {} |
| try { |
| renderPassEncoder0.draw(405, 286, 291_539_782, 541_882_848); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer33, 10_188); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(7, buffer6, 1_192, 128); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| let textureView125 = texture145.createView({aspect: 'depth-only'}); |
| let sampler81 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 53.96, |
| lodMaxClamp: 87.87, |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder109.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 29, 0, 28_681_511, 2_327_117_748); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(5, undefined); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder146 = device0.createCommandEncoder({label: '\u0cb8\ufd3f'}); |
| let textureView126 = texture8.createView({}); |
| let computePassEncoder110 = commandEncoder146.beginComputePass({}); |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer50, 'uint16', 5_860, 1_127); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline0); |
| } catch {} |
| let textureView127 = texture140.createView({}); |
| try { |
| computePassEncoder75.setBindGroup(0, bindGroup68, new Uint32Array(418), 47, 0); |
| } catch {} |
| try { |
| computePassEncoder110.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup28, new Uint32Array(3315), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(9, 29, 0, 123_833_302, 1_043_385_154); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(1, buffer86, 0, 38); |
| } catch {} |
| let buffer91 = device0.createBuffer({ |
| size: 45, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder101.setBindGroup(0, bindGroup64); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup63); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(108, 720, 1_302, 198_815_340, 3_047_932_314); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer52, 2_200); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer49, 9_340); |
| } catch {} |
| try { |
| computePassEncoder61.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let textureView128 = texture95.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(83, 188, 331_489_015, 1_259_618_181); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 25, 0, 721_820_678, 963_083_747); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer33, 6_372); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer50, 'uint32', 852, 1_982); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({ |
| label: '\u4931\u0e70', |
| layout: bindGroupLayout11, |
| entries: [ |
| {binding: 66, resource: textureView74}, |
| {binding: 315, resource: {buffer: buffer57, offset: 0, size: 256}}, |
| {binding: 81, resource: textureView32}, |
| {binding: 106, resource: {buffer: buffer47, offset: 0, size: 101}}, |
| {binding: 21, resource: {buffer: buffer51, offset: 12032, size: 4824}}, |
| {binding: 48, resource: textureView122}, |
| {binding: 347, resource: textureView79}, |
| {binding: 59, resource: textureView66}, |
| ], |
| }); |
| let buffer92 = device0.createBuffer({ |
| size: 8347, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder147 = device0.createCommandEncoder(); |
| let textureView129 = texture74.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder111 = commandEncoder147.beginComputePass({}); |
| try { |
| computePassEncoder73.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder111.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder33.setBlendConstant({ r: -430.7, g: 588.7, b: -504.9, a: 510.6, }); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(22, 71, 1_798_263_597, 196_696_105); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 45, 0, 637_683_152, 211_517_127); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer45, 1_544); |
| } catch {} |
| let bindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 45, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup16, new Uint32Array(2308), 124, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(270, 122, 1_855, 74_395_227, 396_563_546); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer65, 1_056); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer72, 32); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer86, 1_808, 1_462); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| let textureView130 = texture110.createView({}); |
| let computePassEncoder112 = commandEncoder148.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder112.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(140, 286, 658, 229_271_690, 773_503_115); |
| } catch {} |
| try { |
| computePassEncoder35.popDebugGroup(); |
| } catch {} |
| let commandEncoder149 = device0.createCommandEncoder(); |
| let textureView131 = texture117.createView({}); |
| let textureView132 = texture119.createView({format: 'rgba32float'}); |
| let computePassEncoder113 = commandEncoder149.beginComputePass({}); |
| try { |
| computePassEncoder113.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder30.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(83, 99, 169_342_927, 531_262_935); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(0, 73, 7, 141_127_201, 917_800_222); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer60, 572); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder29.insertDebugMarker('\u32be'); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| let buffer93 = device0.createBuffer({ |
| label: '\u0e6a\u0a02', |
| size: 3920, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let textureView133 = texture102.createView({}); |
| try { |
| computePassEncoder54.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder88.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 220, 0, 301_934_054, 103_361_040); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer48, 208); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer60, 72); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup31, new Uint32Array(536), 337, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer17, 336); }; |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup54, new Uint32Array(333), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(81, 40, 37_176_977, 511_732_780); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer19, 892); |
| } catch {} |
| let commandEncoder150 = device0.createCommandEncoder({label: '\u7a41\u8223\u9026\u2143\udfad\u0188\u{1f783}\u4fa7'}); |
| let textureView134 = texture2.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder62.setBindGroup(1, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(25, 443, 19, 1_713_300_166, 723_089_755); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(2, buffer58, 0, 4_671); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture42, |
| mipLevel: 1, |
| origin: {x: 41, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(172).fill(213), /* required buffer size: 172 */ |
| {offset: 172, bytesPerRow: 508, rowsPerImage: 18}, {width: 115, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let computePassEncoder114 = commandEncoder150.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer19, 580); }; |
| } catch {} |
| try { |
| computePassEncoder114.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder29.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(151, 3, 521_669_592, 3_159_622_933); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(29, 84, 217, 131_899_726, 1_014_245_322); |
| } catch {} |
| try { |
| buffer60.destroy(); |
| } catch {} |
| try { |
| buffer62.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 133, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(135).fill(197), /* required buffer size: 135 */ |
| {offset: 135}, {width: 38, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise18; |
| } catch {} |
| let commandEncoder151 = device0.createCommandEncoder({}); |
| let texture151 = device0.createTexture({ |
| size: [164, 12, 484], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder34 = commandEncoder151.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView132, |
| depthSlice: 443, |
| clearValue: { r: 412.5, g: 160.6, b: 763.7, a: -248.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| depthStencilAttachment: {view: textureView91, depthClearValue: -8.978404347622664, depthReadOnly: true}, |
| }); |
| try { |
| renderPassEncoder31.setBindGroup(1, bindGroup5, new Uint32Array(677), 44, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(281, 381, 73, 263_010_274, 529_236_301); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer69, 2628, new DataView(new ArrayBuffer(1619)), 1072, 16); |
| } catch {} |
| let imageData24 = new ImageData(8, 56); |
| let commandEncoder152 = device0.createCommandEncoder({}); |
| let texture152 = device0.createTexture({ |
| size: [2880, 4, 1], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler82 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 98.49, |
| lodMaxClamp: 98.92, |
| maxAnisotropy: 6, |
| }); |
| try { |
| renderPassEncoder17.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(47, 139, 2, 147_832_817, 27_458_274); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(3, buffer66, 0); |
| } catch {} |
| try { |
| buffer39.label = '\u{1f973}\ueada\ub3ed\ufed9\u012b\u8256\u36cf\u0c73\ua257\u0073\ue8ca'; |
| } catch {} |
| let textureView135 = texture138.createView({}); |
| let computePassEncoder115 = commandEncoder152.beginComputePass({}); |
| let sampler83 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 4.941, |
| lodMaxClamp: 98.72, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder70.setBindGroup(2, bindGroup30); |
| } catch {} |
| try { |
| computePassEncoder0.dispatchWorkgroupsIndirect(buffer40, 1_880); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(72, 5, 244_211_982, 6_520_326); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer40, 'uint32', 596, 822); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(4_294_967_294, undefined, 759_464_712, 74_258_199); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let commandEncoder153 = device0.createCommandEncoder(); |
| let querySet19 = device0.createQuerySet({type: 'occlusion', count: 314}); |
| let computePassEncoder116 = commandEncoder153.beginComputePass({}); |
| try { |
| computePassEncoder116.setBindGroup(0, bindGroup61, new Uint32Array(831), 138, 0); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup74, new Uint32Array(1034), 128, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer33, 5_376); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 60, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(382).fill(8), /* required buffer size: 382 */ |
| {offset: 382, bytesPerRow: 144}, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'jedecP22Phosphors', transfer: 'hlg'} }); |
| try { |
| computePassEncoder116.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(84, 142, 225_674_562, 1_531_738_870); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(0, 130, 0, -1_361_918_863, 281_322_670); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer16, 5_452); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(84).fill(219), /* required buffer size: 84 */ |
| {offset: 84}, {width: 69, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 180, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture87, |
| mipLevel: 3, |
| origin: {x: 83, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\ufc6a\ueae8\u0f1b\u04f3\u{1fda3}\u78dd\u04fa\uc917'; |
| } catch {} |
| let buffer94 = device0.createBuffer({ |
| label: '\ub513\u6160\u0f7d\u0b85', |
| size: 13476, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: true, |
| }); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm']}); |
| let sampler84 = device0.createSampler({ |
| label: '\u0614\uc0da', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 97.54, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder87.setBindGroup(0, bindGroup9, new Uint32Array(3122), 868, 0); |
| } catch {} |
| try { |
| computePassEncoder115.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup10, new Uint32Array(2306), 1_521, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle1, renderBundle0, renderBundle3, renderBundle1, renderBundle4, renderBundle1, renderBundle1, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(502, 311, 589_430_592, 706_430_185); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(4, buffer51, 0, 7_189); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer76, 'uint32', 616, 1_076); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup85 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer64, offset: 0, size: 4}}], |
| }); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup32, []); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer19, 132); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer20, 'uint32', 356, 1_822); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(3, bindGroup63, new Uint32Array(518), 23, 0); |
| } catch {} |
| try { |
| await buffer74.mapAsync(GPUMapMode.READ, 0, 3780); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 0, y: 23 }, |
| flipY: true, |
| }, { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| await gc(); |
| let texture153 = gpuCanvasContext4.getCurrentTexture(); |
| let renderBundle18 = renderBundleEncoder18.finish(); |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup8, new Uint32Array(131), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setBlendConstant({ r: 383.4, g: 305.0, b: -199.5, a: 21.74, }); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer78, 5_988); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer8, 'uint16', 294, 1_061); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer86, 0, 4_678); |
| } catch {} |
| let arrayBuffer10 = buffer66.getMappedRange(7896, 220); |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let texture154 = device0.createTexture({ |
| size: [75, 12, 5], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba32float'], |
| }); |
| let computePassEncoder117 = commandEncoder154.beginComputePass({}); |
| let sampler85 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 69.08, |
| lodMaxClamp: 92.97, |
| }); |
| try { |
| computePassEncoder110.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| computePassEncoder117.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(3, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer65, 468); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer60, 'uint16', 666, 691); |
| } catch {} |
| let buffer95 = device0.createBuffer({size: 1640, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let textureView136 = texture60.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let externalTexture13 = device0.importExternalTexture({source: video1}); |
| try { |
| renderPassEncoder8.drawIndexed(76, 234, 9, 61_826_118, 470_561_986); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder155.copyBufferToTexture({ |
| /* bytesInLastRow: 1344 widthInBlocks: 84 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 880 */ |
| offset: 880, |
| rowsPerImage: 91, |
| buffer: buffer18, |
| }, { |
| texture: texture146, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 84, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let img4 = await imageWithData(141, 42, '#10101010', '#20202020'); |
| let shaderModule14 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 28 max align: 4 */ |
| struct T0 { |
| @size(28) f0: array<atomic<u32>>, |
| } |
| /* target size: 178 max align: 2 */ |
| struct T1 { |
| @align(2) @size(178) f0: array<atomic<u32>>, |
| } |
| /* target size: 139 max align: 1 */ |
| struct T2 { |
| @align(1) @size(139) f0: array<mat4x3f>, |
| } |
| @group(0) @binding(234) var sam6: sampler; |
| @group(0) @binding(49) var st30: texture_storage_1d<rgba16float, write>; |
| @group(0) @binding(15) var tex6: texture_depth_2d; |
| @group(0) @binding(374) var st31: texture_storage_2d<rgba8unorm, read>; |
| struct VertexOutput14 { |
| @builtin(position) f45: vec4f |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput14 { |
| var out: VertexOutput14; |
| return out; |
| } |
| struct VertexOutput15 { |
| @location(0) @interpolate(flat, sample) f46: vec2i, |
| @location(8) f47: vec4u, |
| @location(14) f48: vec2u, |
| @builtin(position) f49: vec4f, |
| @location(13) f50: vec2h |
| } |
| |
| @vertex |
| fn vertex1(@location(7) @interpolate(perspective) a0: f32, @location(3) a1: vec2h, @location(2) @interpolate(linear) a2: vec3f, @location(11) @interpolate(perspective) a3: vec3h) -> VertexOutput15 { |
| var out: VertexOutput15; |
| _ = textureGather(tex6, sam6, vec2f(), vec2i()); |
| return out; |
| } |
| struct FragmentOutput14 { |
| @location(0) f0: vec4f, |
| @location(5) f1: vec4f, |
| @builtin(frag_depth) f2: f32 |
| } |
| |
| @fragment |
| fn fragment0(@location(1) @interpolate(perspective) a0: vec3h, @location(3) @interpolate(flat, center) a1: vec3f) -> FragmentOutput14 { |
| var out: FragmentOutput14; |
| textureStore(st30, 0, vec4f(0.08080, 0.03690, 0.08469, 0.1164)); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 2) |
| fn compute0() { |
| _ = textureLoad(st31, vec2i()); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let texture155 = device0.createTexture({ |
| label: '\uebfe\ub4dc\ub157\u763a\u792c\u0c6d\u{1f86d}\u0a6e\u0ea8\u{1f89d}\u01d5', |
| size: {width: 600, height: 96, depthOrArrayLayers: 560}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView137 = texture0.createView({dimension: '2d-array', format: 'r32float'}); |
| let computePassEncoder118 = commandEncoder155.beginComputePass({}); |
| try { |
| renderPassEncoder17.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(4, 23, 387_116_998, 157_657_738); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(63, 87, 47, -2_049_912_626, 465_264_045); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer57, 492); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer48, 10264, new Float32Array(1386), 123, 4); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| await gc(); |
| let bindGroup86 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 135, resource: textureView112}]}); |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| let texture156 = device0.createTexture({ |
| label: '\u310d\udaab\u02d0\u4168\u36a1', |
| size: {width: 2, height: 2, depthOrArrayLayers: 21}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView138 = texture16.createView({format: 'rgba32uint'}); |
| try { |
| computePassEncoder31.setBindGroup(1, bindGroup68, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer72, 36); }; |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup30, new Uint32Array(1034), 761, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(38, 84, 368_886_949, 325_376_529); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer57, 360); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer1, 'uint32', 17_224, 1_498); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(4, buffer53, 0, 182); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let buffer96 = device0.createBuffer({size: 177, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroupsIndirect(buffer17, 3_152); }; |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup76); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(31, 137, 47, 200_332_424, 776_953_945); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer15, 3_544); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer19, 2_288); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(474, 28); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let texture157 = device0.createTexture({ |
| size: {width: 329, height: 24, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView139 = texture148.createView({label: '\uebf0\ud317\u6f45\u0bb0\u06f2\u{1fc83}\u0531\u{1ff99}\ubb70\u38d1\uf30f', baseArrayLayer: 0}); |
| let renderPassEncoder35 = commandEncoder156.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView132, |
| depthSlice: 343, |
| clearValue: { r: 166.5, g: 886.6, b: -21.38, a: 300.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView91, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilReadOnly: false, |
| }, |
| occlusionQuerySet: querySet8, |
| maxDrawCount: 68252895, |
| }); |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(1, bindGroup22, new Uint32Array(180), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(31, 219, 61, 258_430_148, 203_044_437); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer73, 328); |
| } catch {} |
| try { |
| commandEncoder157.clearBuffer(buffer49, 1908, 18460); |
| } catch {} |
| try { |
| commandEncoder157.resolveQuerySet(querySet8, 21, 46, buffer24, 8192); |
| } catch {} |
| let shaderModule15 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| enable f16; |
| /* target size: 43 max align: 1 */ |
| struct T0 { |
| @align(1) @size(3) f0: f16, |
| @align(1) @size(40) f1: array<atomic<i32>>, |
| } |
| @group(0) @binding(49) var st32: texture_storage_1d<rgba32float, write>; |
| @group(0) @binding(374) var st33: texture_storage_2d<rgba8unorm, read>; |
| @group(0) @binding(234) var sam7: sampler; |
| @group(0) @binding(15) var tex7: texture_2d<u32>; |
| struct VertexOutput16 { |
| @location(0) @interpolate(flat, center) f51: i32, |
| @location(3) @interpolate(perspective, sample) f52: vec3f, |
| @location(11) f53: u32, |
| @builtin(position) f54: vec4f |
| } |
| |
| @vertex |
| fn vertex0(@location(7) a0: vec2f, @location(2) a1: vec3u) -> VertexOutput16 { |
| var out: VertexOutput16; |
| out.f52 = bitcast<vec3f>(textureGather(0, tex7, sam7, vec2f()).ywx); |
| return out; |
| } |
| struct FragmentOutput15 { |
| @location(1) @interpolate(linear) f0: vec3f, |
| @location(3) f1: vec3f, |
| @location(0) f2: vec4f, |
| @builtin(frag_depth) f3: f32 |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput15 { |
| var out: FragmentOutput15; |
| if bool(textureLoad(st33, vec2i())[3]) { |
| textureStore(st32, 0, vec4f(0.07618, 0.06026, 0.6390, 0.00006)); |
| } |
| return out; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| let computePassEncoder119 = commandEncoder158.beginComputePass({label: '\u067a\u0349\uf8d0\uc171\ube51'}); |
| try { |
| computePassEncoder118.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder21.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer73, 5_380); |
| } catch {} |
| let imageData25 = new ImageData(20, 16); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder69.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer49, 22_708); }; |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle9, renderBundle18, renderBundle0, renderBundle2]); |
| } catch {} |
| let pipelineLayout16 = device0.createPipelineLayout({label: '\u33d3\u7d48\u01b2\u{1f997}\u{1f9aa}', bindGroupLayouts: []}); |
| let texture158 = device0.createTexture({size: {width: 82}, dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder120 = commandEncoder159.beginComputePass({}); |
| try { |
| computePassEncoder75.setBindGroup(0, bindGroup15, new Uint32Array(1878), 149, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(8, 43, 46, 224_327_825, 86_759_202); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer51, 908); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let arrayBuffer11 = buffer77.getMappedRange(); |
| try { |
| commandEncoder157.copyBufferToBuffer(buffer64, 60, buffer43, 7620, 4); |
| } catch {} |
| try { |
| commandEncoder157.clearBuffer(buffer51, 4640, 2292); |
| } catch {} |
| let buffer97 = device0.createBuffer({size: 317, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let textureView140 = texture155.createView({mipLevelCount: 1}); |
| let sampler86 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 9.861, |
| maxAnisotropy: 1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer60, 3_276); }; |
| } catch {} |
| try { |
| computePassEncoder119.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup41, new Uint32Array(4032), 1_177, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(18, 46, 11, 478_019_164, 264_297_957); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer19, 408); |
| } catch {} |
| try { |
| buffer60.unmap(); |
| } catch {} |
| let pipeline11 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| multisample: {mask: 0x153ccaf0}, |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{ |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'dst'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 504, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x3', offset: 24, shaderLocation: 1}, |
| {format: 'sint32x3', offset: 12, shaderLocation: 0}, |
| {format: 'float32x3', offset: 124, shaderLocation: 13}, |
| {format: 'sint8x4', offset: 68, shaderLocation: 2}, |
| {format: 'sint32', offset: 48, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 40, shaderLocation: 7}, |
| {format: 'float32', offset: 196, shaderLocation: 8}, |
| {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 4}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 10}, |
| {format: 'uint32x2', offset: 16, shaderLocation: 6}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 9}, |
| {format: 'snorm16x2', offset: 80, shaderLocation: 12}, |
| {format: 'float32x2', offset: 124, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: false}, |
| }); |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'log'} }); |
| try { |
| renderPassEncoder22.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer19, 6_064); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer82, 'uint32', 560, 418); |
| } catch {} |
| let buffer98 = device0.createBuffer({size: 5139, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder160 = device0.createCommandEncoder(); |
| let texture159 = device0.createTexture({ |
| label: '\u0946\u0075\u0dfd\u{1fbe2}\uc257\u9dcc\uaeda', |
| size: {width: 1440, height: 2, depthOrArrayLayers: 596}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder121 = commandEncoder160.beginComputePass({}); |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(9, 73, 47, 122_196_662, 17_141_178); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline9); |
| } catch {} |
| try { |
| commandEncoder157.resolveQuerySet(querySet1, 442, 0, buffer87, 2816); |
| } catch {} |
| let gpuCanvasContext5 = canvas3.getContext('webgpu'); |
| let shaderModule16 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 4 max align: 4 */ |
| struct T0 { |
| f0: u32, |
| } |
| @group(0) @binding(234) var sam8: sampler; |
| @group(0) @binding(374) var st35: texture_storage_2d<r32uint, read>; |
| @group(0) @binding(15) var tex8: texture_depth_cube; |
| @group(0) @binding(49) var st34: texture_storage_2d_array<r32float, write>; |
| struct VertexOutput17 { |
| @location(6) @interpolate(flat) f55: vec2u, |
| @builtin(position) f56: vec4f |
| } |
| |
| @vertex |
| fn vertex0(@location(14) a0: vec3f, @location(6) @interpolate(flat, sample) a1: vec4h, @location(12) a2: vec3i) -> VertexOutput17 { |
| var out: VertexOutput17; |
| _ = a1; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute0() { |
| }`, |
| hints: {}, |
| }); |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| let texture160 = device0.createTexture({ |
| size: [164, 12, 1], |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture161 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder121.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(3, bindGroup38, new Uint32Array(6597), 213, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(6, 63, 74_654_742, 136_352_378); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer72, 12); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer17, 676); |
| } catch {} |
| let imageData26 = new ImageData(20, 60); |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let bindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 102, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let sampler87 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 63.40, |
| lodMaxClamp: 94.00, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder120.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup0, new Uint32Array(2066), 48, 0); |
| } catch {} |
| try { |
| commandEncoder161.copyBufferToBuffer(buffer95, 636, buffer13, 328, 356); |
| } catch {} |
| let texture162 = device0.createTexture({ |
| label: '\u570d\u0fde\u{1ff98}\u7cbe\u8101', |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler88 = device0.createSampler({ |
| label: '\u0d2f\u0fcb\ue013\u{1fecd}\u06a8\ub16b\u3fca\u{1fb26}\u{1fa05}\uc5fc\u0889', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 43.25, |
| }); |
| try { |
| computePassEncoder106.setBindGroup(3, bindGroup55); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroupsIndirect(buffer67, 6_212); }; |
| } catch {} |
| try { |
| renderPassEncoder25.setBlendConstant({ r: 723.1, g: 330.5, b: 63.11, a: -730.1, }); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(34, 62, 57, -1_945_497_117, 256_741_388); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer80, 72); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer83, 1060, new Int16Array(20330), 480, 716); |
| } catch {} |
| let imageData27 = new ImageData(20, 8); |
| let buffer99 = device0.createBuffer({ |
| size: 4156, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder162 = device0.createCommandEncoder({label: '\u959f\uf1fa\ude0a\u0870\uc30f\u0edc\u58f6\u12cd\u84e3'}); |
| let computePassEncoder122 = commandEncoder162.beginComputePass({label: '\u045b\u507e\u{1fd78}\u83b0'}); |
| let renderPassEncoder36 = commandEncoder161.beginRenderPass({colorAttachments: [{view: textureView104, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder25.setBindGroup(2, bindGroup86, new Uint32Array(5034), 293, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setViewport(1093.633535211568, 3.7216241057830572, 146.65236096386172, 0.0013866202635035296, 0.8582726673097886, 0.9046485408621482); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(154, 52, 2_045_617_415, 149_911_910); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(67, 15, 3, 135_929_301, 588_774_213); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer15, 84); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer97, 'uint16', 28, 5); |
| } catch {} |
| let renderPassEncoder37 = commandEncoder157.beginRenderPass({ |
| label: '\uf4f2\udcc2\u{1fdb7}\u0c7f\u01e5\ud8ec', |
| colorAttachments: [{ |
| view: textureView86, |
| clearValue: { r: -656.3, g: 616.8, b: 679.3, a: -338.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData23, |
| origin: { x: 6, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 45, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| let textureView141 = texture15.createView({mipLevelCount: 1}); |
| let renderPassEncoder38 = commandEncoder163.beginRenderPass({ |
| colorAttachments: [{view: textureView132, depthSlice: 283, loadOp: 'load', storeOp: 'store'}], |
| depthStencilAttachment: {view: textureView128, depthLoadOp: 'load', depthStoreOp: 'store'}, |
| maxDrawCount: 588929002, |
| }); |
| let sampler89 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 5.080, |
| lodMaxClamp: 31.17, |
| }); |
| try { |
| renderPassEncoder29.executeBundles([renderBundle18]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(274, 83, 661_316_937, 498_660_928); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(24, 127, 109, 689_733_462, 1_276_785_476); |
| } catch {} |
| let querySet20 = device0.createQuerySet({type: 'occlusion', count: 137}); |
| try { |
| computePassEncoder122.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle9, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer17, 1_008); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let commandEncoder164 = device0.createCommandEncoder({label: '\uf026\u0365\u03e7\u02f5\u00d3'}); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['r8unorm'], depthReadOnly: true}); |
| let renderBundle19 = renderBundleEncoder19.finish(); |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle11, renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(183, 2, 48, 248_542_725, 330_696_521); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer52, 1_232); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer65, 112); |
| } catch {} |
| try { |
| commandEncoder164.copyBufferToBuffer(buffer87, 3780, buffer1, 8584, 424); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup87 = device0.createBindGroup({ |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 15, resource: {buffer: buffer21, offset: 256, size: 640}}, |
| {binding: 0, resource: textureView50}, |
| ], |
| }); |
| let pipelineLayout17 = device0.createPipelineLayout({label: '\u663b\u0c1b\u{1ff8e}\u{1fad8}\u{1fe93}', bindGroupLayouts: []}); |
| let textureView142 = texture78.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder123 = commandEncoder164.beginComputePass(); |
| try { |
| computePassEncoder93.setBindGroup(0, bindGroup85); |
| } catch {} |
| try { |
| computePassEncoder123.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer65, 280); |
| } catch {} |
| let gpuCanvasContext6 = offscreenCanvas3.getContext('webgpu'); |
| let texture163 = device0.createTexture({ |
| size: [720, 1, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder0.drawIndexed(4, 142, 21, 511_160_709, 989_964_859); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer21, 616); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| document.body.append(video0); |
| await gc(); |
| let buffer100 = device0.createBuffer({ |
| size: 9833, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder165 = device0.createCommandEncoder({}); |
| let computePassEncoder124 = commandEncoder165.beginComputePass({}); |
| try { |
| computePassEncoder86.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder124.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(5, 33, 0, 137_863_967, 330_003_904); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer56, 3_756); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroup88 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 90, resource: textureView11}]}); |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let textureView143 = texture102.createView({}); |
| try { |
| computePassEncoder80.setBindGroup(1, bindGroup72); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(102, 54, 28, 586_369_563, 1_148_807_639); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer50, 'uint16', 2_042, 687); |
| } catch {} |
| try { |
| querySet16.destroy(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 720, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 8, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture69, |
| mipLevel: 2, |
| origin: {x: 96, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| label: '\uacaf\u1702\ucc39\u1bdc\u4d63\uc05a\u66c3\u8516\u08c9\u01c6', |
| layout: bindGroupLayout13, |
| entries: [{binding: 168, resource: textureView74}], |
| }); |
| let buffer101 = device0.createBuffer({ |
| size: 16171, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView144 = texture109.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let sampler90 = device0.createSampler({ |
| label: '\u42db\u0ea0\u4454\ud5a4\u{1fe75}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 4.787, |
| lodMaxClamp: 95.03, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle3, renderBundle0, renderBundle9, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder35.setViewport(243.75154887317288, 6.3827254564228255, 4.1545320402377826, 7.427079834019456, 0.015302543692971793, 0.8542108953188547); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer48, 448); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer45, 3_136); |
| } catch {} |
| try { |
| texture29.destroy(); |
| } catch {} |
| try { |
| commandEncoder166.copyBufferToTexture({ |
| /* bytesInLastRow: 272 widthInBlocks: 68 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 904 */ |
| offset: 904, |
| bytesPerRow: 512, |
| rowsPerImage: 47, |
| buffer: buffer22, |
| }, { |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 108, y: 13, z: 0}, |
| aspect: 'all', |
| }, {width: 68, height: 27, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise19; |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let texture164 = device0.createTexture({ |
| size: {width: 600, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder125 = commandEncoder167.beginComputePass(); |
| let renderPassEncoder39 = commandEncoder166.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView83, |
| clearValue: { r: -657.6, g: -223.6, b: -756.7, a: 5.743, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 38261801, |
| }); |
| let sampler91 = device0.createSampler({ |
| label: '\u0001\u4228\u{1fec9}\ubf39\u13e4\u470c\u0e74\uaade\u0672', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 85.68, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder111.setBindGroup(1, bindGroup18, new Uint32Array(232), 69, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer101, 2_344); }; |
| } catch {} |
| try { |
| computePassEncoder125.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(145, 43, 257_898_376, 936_914_573); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer33, 684); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer48, 4_772); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer53, 'uint32', 48, 1_182); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(451).fill(45), /* required buffer size: 451 */ |
| {offset: 451}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout18 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout17]}); |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let texture165 = device0.createTexture({ |
| size: [300, 48, 1], |
| sampleCount: 1, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView145 = texture157.createView({baseMipLevel: 0}); |
| let computePassEncoder126 = commandEncoder168.beginComputePass({}); |
| try { |
| computePassEncoder82.setBindGroup(1, bindGroup86, new Uint32Array(1715), 38, 0); |
| } catch {} |
| try { |
| computePassEncoder126.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder24.setScissorRect(3, 0, 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(7, buffer39); |
| } catch {} |
| let arrayBuffer12 = buffer78.getMappedRange(); |
| try { |
| renderPassEncoder11.insertDebugMarker('\uc839'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 2468, new Int16Array(9055), 672, 1824); |
| } catch {} |
| let textureView146 = texture83.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup56); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(0, bindGroup70, new Uint32Array(1522), 380, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setScissorRect(37, 12, 3, 2); |
| } catch {} |
| try { |
| renderPassEncoder24.setViewport(50.179310979569735, 4.5748940261046585, 3.9320646705784266, 0.9984514275671209, 0.0790438074860973, 0.42234160629144873); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(262, 30, 347_259_795, 673_473_652); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer21, 1_036); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer76, 'uint16', 4, 631); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline9); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let imageData28 = new ImageData(160, 60); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer26, 320); }; |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(1, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer100, 564); |
| } catch {} |
| let bindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 91, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer102 = device0.createBuffer({ |
| size: 10276, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let querySet21 = device0.createQuerySet({type: 'occlusion', count: 236}); |
| let sampler92 = device0.createSampler({ |
| label: '\ucd99\u8f59\u03ee\uc9f2\uad4a\u3d9f\u0658', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 97.65, |
| lodMaxClamp: 98.92, |
| compare: 'less', |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder116.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup67, new Uint32Array(826), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(44, 2, 92, 551_659_052, 198_595_395); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer78, 172); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let texture166 = device0.createTexture({ |
| size: {width: 720, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView147 = texture155.createView({mipLevelCount: 1}); |
| let computePassEncoder127 = commandEncoder153.beginComputePass({}); |
| try { |
| computePassEncoder127.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer38, 32); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, undefined); |
| } catch {} |
| let commandEncoder169 = device0.createCommandEncoder({label: '\ua9b2\u4d6c\u072f\u5292\u09d3\u{1fc34}\ub913\u738c\ue55e\u8250\uea0a'}); |
| let computePassEncoder128 = commandEncoder169.beginComputePass({}); |
| try { |
| computePassEncoder80.setBindGroup(2, bindGroup32); |
| } catch {} |
| try { |
| computePassEncoder49.setBindGroup(1, bindGroup83, new Uint32Array(275), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(215, 64, 333_831_409, 248_400_462); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(40, 154, 41, 331_233_789, 2_891_469_220); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer20, 'uint32', 728, 4_075); |
| } catch {} |
| try { |
| await buffer44.mapAsync(GPUMapMode.READ, 80, 644); |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpteRp431', transfer: 'log'} }); |
| let bindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 369, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder61.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| computePassEncoder87.setBindGroup(1, bindGroup63, new Uint32Array(90), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup16, new Uint32Array(2819), 727, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer27, 44); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let texture167 = device0.createTexture({ |
| label: '\u0b8d\uc238\u0e4b\u7a1f\u2f1a\uc5af\u07dc', |
| size: [659, 48, 36], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm'], |
| }); |
| let externalTexture14 = device0.importExternalTexture({source: video3}); |
| try { |
| computePassEncoder121.setBindGroup(0, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer42, 8); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer48, 1_512); |
| } catch {} |
| let commandEncoder170 = device0.createCommandEncoder({}); |
| let sampler93 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 49.18, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder86.setBindGroup(0, bindGroup83); |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder128.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(3, bindGroup42, new Uint32Array(1143), 48, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setScissorRect(58, 3, 5, 3); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(73, 83, 5, -2_049_912_434, 57_107_869); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer45, 1_748); |
| } catch {} |
| try { |
| commandEncoder170.copyTextureToBuffer({ |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 46 widthInBlocks: 23 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 70 */ |
| offset: 70, |
| rowsPerImage: 383, |
| buffer: buffer60, |
| }, {width: 23, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder171 = device0.createCommandEncoder({label: '\ud935\u45d3\u{1f9f6}\u779a\ua0f7\u{1fe12}\uc523\u0b1e\u75ea\u916a'}); |
| let texture168 = device0.createTexture({ |
| size: [2880], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView148 = texture67.createView({dimension: '2d'}); |
| let computePassEncoder129 = commandEncoder171.beginComputePass({}); |
| let renderPassEncoder40 = commandEncoder170.beginRenderPass({ |
| label: '\u{1f655}\u2395', |
| colorAttachments: [{view: textureView48, depthSlice: 2, loadOp: 'load', storeOp: 'store'}], |
| }); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle20 = renderBundleEncoder20.finish({}); |
| try { |
| computePassEncoder119.setBindGroup(3, bindGroup51, new Uint32Array(699), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder129.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(24, 214, 10, 15_800_364, 135_040_816); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(imageData3); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup5, new Uint32Array(1896), 318, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(44, 309, 278_627_760, 83_092_508); |
| } catch {} |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer76, 'uint32', 988, 106); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(0, buffer70); |
| } catch {} |
| let arrayBuffer13 = buffer102.getMappedRange(3240, 656); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture130, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(298).fill(48), /* required buffer size: 298 */ |
| {offset: 298, bytesPerRow: 95, rowsPerImage: 52}, {width: 40, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let texture169 = device0.createTexture({ |
| size: [164], |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder71.setBindGroup(0, bindGroup86); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(0, bindGroup85, new Uint32Array(1098), 138, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setScissorRect(0, 1, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(66, 193, 173_475_763, 1_409_360_284); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(27, 1, 2, 188_014_249, 49_891_043); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer21, 1_944); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer61, 1_688); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let renderPassEncoder41 = commandEncoder172.beginRenderPass({ |
| label: '\ueb8f\u8970\u09b5\u8c91\udc3c\u04e5\u861d', |
| colorAttachments: [{ |
| view: textureView43, |
| clearValue: { r: 283.0, g: 172.8, b: -970.0, a: -839.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler94 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 3.531, |
| lodMaxClamp: 84.18, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(3, bindGroup26, new Uint32Array(182), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setScissorRect(171, 1, 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer51, 4_032); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer93, 0, 556); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer75, 3004, new BigUint64Array(2633), 118, 240); |
| } catch {} |
| document.body.append(video2); |
| let imageData29 = new ImageData(112, 16); |
| let bindGroup90 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 102, resource: textureView28}]}); |
| let buffer103 = device0.createBuffer({size: 17428, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let externalTexture15 = device0.importExternalTexture({source: video2}); |
| try { |
| renderPassEncoder3.draw(87, 378, 1_840_813_381, 120_683_982); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(3, 9, 11, 232_183_348, 213_729_829); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer68, 816); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer40, 704); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(5, buffer70, 564); |
| } catch {} |
| await gc(); |
| let textureView149 = texture69.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder50.setBindGroup(3, bindGroup61, new Uint32Array(5327), 731, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer65, 408); }; |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(0, bindGroup50, []); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(284.4021280480056, 11.79643322766205, 15.03747421202583, 22.11653743684152, 0.5085604683719953, 0.8805593281519726); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer49, 2_196); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer50, 1_020); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline0); |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView1}]}); |
| let commandEncoder173 = device0.createCommandEncoder({}); |
| let texture170 = device0.createTexture({ |
| size: [600, 96, 1], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder27.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer56, 6_988); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer102, 'uint32', 844, 601); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture170, |
| mipLevel: 0, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'depth-only', |
| }, new Uint8Array(71).fill(111), /* required buffer size: 71 */ |
| {offset: 71}, {width: 600, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup92 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 28, resource: {buffer: buffer21, offset: 512}}]}); |
| let buffer104 = device0.createBuffer({ |
| size: 1545, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder130 = commandEncoder173.beginComputePass({label: '\u3736\u0b12\udc77\u3354\u0145\u08df\ue599\u9ff6\u0b2d\ue938'}); |
| try { |
| computePassEncoder55.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer57, 152); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 9, y: 10, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(607).fill(198), /* required buffer size: 607 */ |
| {offset: 607}, {width: 54, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| window.someLabel = textureView57.label; |
| } catch {} |
| let buffer105 = device0.createBuffer({ |
| size: 10178, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| let texture171 = device0.createTexture({ |
| size: {width: 150, height: 24, depthOrArrayLayers: 24}, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView150 = texture43.createView({}); |
| let renderPassEncoder42 = commandEncoder174.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView127, |
| depthSlice: 354, |
| clearValue: { r: 546.0, g: -484.3, b: -326.5, a: 767.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder103.setBindGroup(0, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup65, new Uint32Array(2864), 101, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer27, 216); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer40, 52); |
| } catch {} |
| let commandEncoder175 = device0.createCommandEncoder({label: '\u4ce7\u0994\u2c68\u{1fffc}\u1317'}); |
| let computePassEncoder131 = commandEncoder175.beginComputePass({}); |
| let sampler95 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 45.96, |
| lodMaxClamp: 87.60, |
| }); |
| try { |
| renderPassEncoder42.setBindGroup(3, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(119, 129, 73_796_658, 1_507_668_245); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer104, 40); |
| } catch {} |
| try { |
| buffer100.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture172 = device0.createTexture({ |
| label: '\u4f6b\ue1ee', |
| size: {width: 659, height: 48, depthOrArrayLayers: 481}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle21 = renderBundleEncoder21.finish({}); |
| try { |
| computePassEncoder26.dispatchWorkgroupsIndirect(buffer70, 2_036); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(3, bindGroup75, new Uint32Array(173), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer17, 2_116); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(1, buffer75, 0, 642); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1440, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData18, |
| origin: { x: 36, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture69, |
| mipLevel: 1, |
| origin: {x: 157, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let video4 = await videoWithData(105); |
| let bindGroup93 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView7}]}); |
| let texture173 = device0.createTexture({ |
| size: [360, 1, 1], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler96 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 53.66, |
| lodMaxClamp: 84.67, |
| }); |
| try { |
| computePassEncoder123.setBindGroup(2, bindGroup19, new Uint32Array(2035), 456, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer102, 1_396); }; |
| } catch {} |
| try { |
| renderPassEncoder8.draw(186, 72, 280_506_094, 61_781_577); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer26, 356); |
| } catch {} |
| let arrayBuffer14 = buffer61.getMappedRange(680, 708); |
| try { |
| device0.queue.writeBuffer(buffer29, 920, new Float32Array(14138), 433, 120); |
| } catch {} |
| let bindGroupLayout24 = device0.createBindGroupLayout({ |
| label: '\u07aa\ud38d\u6ff5\uc24c\uc277\u0f53\u40ad\u5d2a\u{1fbef}\u{1f700}', |
| entries: [ |
| { |
| binding: 457, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer106 = device0.createBuffer({ |
| label: '\u4e6a\u904b\u5c52', |
| size: 17640, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let sampler97 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 22.58, |
| }); |
| try { |
| computePassEncoder76.end(); |
| } catch {} |
| try { |
| computePassEncoder130.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(94, 264, 138_718_637, 72_092_687); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer17, 132); |
| } catch {} |
| try { |
| if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55); }; |
| } catch {} |
| try { |
| window.someLabel = commandEncoder122.label; |
| } catch {} |
| let textureView151 = texture56.createView({mipLevelCount: 1}); |
| let computePassEncoder132 = commandEncoder100.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer66, 13_692); }; |
| } catch {} |
| try { |
| computePassEncoder132.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup85, new Uint32Array(1437), 442, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(79, 82, 1_214_178_390, 213_837_844); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(47, 222, 48, -2_112_463_762, 521_523_590); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer73, 4_240); |
| } catch {} |
| try { |
| renderPassEncoder41.setIndexBuffer(buffer82, 'uint16', 90, 62); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline9); |
| } catch {} |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| let renderPassEncoder43 = commandEncoder176.beginRenderPass({ |
| colorAttachments: [{view: textureView132, depthSlice: 313, loadOp: 'load', storeOp: 'store'}], |
| depthStencilAttachment: { |
| view: textureView128, |
| depthClearValue: 0.36221489807880647, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilClearValue: 6140, |
| stencilReadOnly: true, |
| }, |
| occlusionQuerySet: querySet11, |
| }); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| renderPassEncoder3.draw(139, 37, 736_170_734, 2_305_010_193); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 51, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer107 = device0.createBuffer({ |
| size: 4345, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let querySet22 = device0.createQuerySet({type: 'occlusion', count: 6}); |
| let texture174 = device0.createTexture({size: {width: 150}, dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView152 = texture164.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup54, new Uint32Array(6052), 1_210, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.setScissorRect(1, 0, 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(295, 89, 801_425_976, 27_920_527); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(41, 127, 5, 410_693_575, 209_308_904); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer48, 744, new BigUint64Array(1885), 483, 48); |
| } catch {} |
| let buffer108 = device0.createBuffer({ |
| size: 2916, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| let renderPassEncoder44 = commandEncoder177.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView43, |
| clearValue: { r: -814.6, g: -354.8, b: -938.0, a: -168.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet4, |
| }); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({ |
| label: '\u{1fd5f}\u0a8f\ueb78\u0195\u{1fadf}', |
| colorFormats: ['rgba32float'], |
| depthStencilFormat: 'depth16unorm', |
| depthReadOnly: true, |
| }); |
| try { |
| computePassEncoder131.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(598, 133, 560_576_160, 379_595_362); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer52, 512); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer21, 'uint16', 186, 464); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(1, buffer68); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer40, 'uint16', 710, 41); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture124, |
| mipLevel: 3, |
| origin: {x: 11, y: 1, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(37).fill(12), /* required buffer size: 37 */ |
| {offset: 37}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture8.label = '\u119e\u008c\u0d09'; |
| } catch {} |
| let textureView153 = texture85.createView({dimension: '2d-array'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer15, 440); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(114, 353, 1_000_577_493, 314_187_264); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(70, 21, 8, 723_274_141, 149_716_765); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer107, 532); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer67, 0, 4_840); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup77, new Uint32Array(666), 18, 0); |
| } catch {} |
| try { |
| buffer95.unmap(); |
| } catch {} |
| let texture175 = device0.createTexture({size: [75, 12, 1], format: 'depth16unorm', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| let sampler98 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 51.93, |
| lodMaxClamp: 91.14, |
| compare: 'greater-equal', |
| }); |
| try { |
| renderPassEncoder41.setViewport(2.3167413378224255, 2.9914886692178566, 26.379119722197956, 0.006065844267394649, 0.5230669824912908, 0.8171814276798959); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(19, 56, 2_600_989_275, 336_850_000); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer21, 424); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 9} |
| */ |
| { |
| source: videoFrame20, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture42, |
| mipLevel: 2, |
| origin: {x: 7, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let pipelineLayout19 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder178 = device0.createCommandEncoder({label: '\u015b\u3dcd\u05a6\ud4ff\u1813\u6040'}); |
| let textureView154 = texture117.createView({dimension: '2d-array'}); |
| let computePassEncoder133 = commandEncoder178.beginComputePass({}); |
| let renderBundle22 = renderBundleEncoder22.finish(); |
| let sampler99 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 5.639, |
| lodMaxClamp: 12.30, |
| maxAnisotropy: 3, |
| }); |
| try { |
| computePassEncoder112.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder35.setScissorRect(62, 19, 5, 6); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(53, 2, 35_949_468, 967_660_526); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline7); |
| } catch {} |
| await gc(); |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| let computePassEncoder134 = commandEncoder179.beginComputePass({}); |
| let sampler100 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 41.27, |
| lodMaxClamp: 60.70, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder133.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer100, 1_292); |
| } catch {} |
| try { |
| buffer80.destroy(); |
| } catch {} |
| try { |
| window.someLabel = sampler37.label; |
| } catch {} |
| let buffer109 = device0.createBuffer({size: 22861, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder180 = device0.createCommandEncoder({}); |
| let renderPassEncoder45 = commandEncoder180.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView115, |
| clearValue: { r: -514.8, g: -474.4, b: 584.0, a: -44.56, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder74.setBindGroup(0, bindGroup66, new Uint32Array(773), 33, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(1, bindGroup87, new Uint32Array(1808), 76, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(49, 274, 63, 590_479_760, 2_601_304_627); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline7); |
| } catch {} |
| let texture176 = device0.createTexture({ |
| size: [659], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder77.setBindGroup(2, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder71.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer27, 180); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(7, buffer75, 0, 23_883); |
| } catch {} |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'bt2020_12bit'} }); |
| try { |
| computePassEncoder133.setBindGroup(0, bindGroup61, new Uint32Array(4233), 782, 0); |
| } catch {} |
| try { |
| computePassEncoder134.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(371, 64, 3_550_307_321, 1_309_471_401); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(23, 172, 38, 889_182_182, 251_337_230); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer73, 10_480); |
| } catch {} |
| try { |
| computePassEncoder112.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder28.setBlendConstant({ r: 189.8, g: -322.5, b: 107.8, a: 113.0, }); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(50, 136, 1_591_994_782, 2_724_585_155); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer70, 1_448); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer38, 620); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline11); |
| } catch {} |
| try { |
| adapter0.label = '\u931c\ue41c\uf2f2\ucdb0\u0289\ua6a2\u0085\u00a1'; |
| } catch {} |
| let commandEncoder181 = device0.createCommandEncoder({label: '\u{1fa07}\ufe83\u64f2\u0cc3\u85e7\u{1fb09}\u024f\u19e8\u{1fda3}\u{1f63d}\u40b7'}); |
| let textureView155 = texture93.createView({ |
| label: '\u1a48\u{1f842}\u7293\ub677\u0ff0\u0a16\ua50d\u07f1\ub754\u08e1', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| arrayLayerCount: 1, |
| }); |
| let computePassEncoder135 = commandEncoder181.beginComputePass(); |
| try { |
| computePassEncoder123.setBindGroup(3, bindGroup86, new Uint32Array(300), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(89, 2, 1_884_314_398, 977_827_448); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(7, buffer25); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let buffer110 = device0.createBuffer({ |
| size: 2393, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| renderPassEncoder0.draw(4, 112, 0, 165_881_625); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(25, 249, 4, -1_907_180_004, 878_110_537); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer8, 'uint16', 582, 122); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder42.setVertexBuffer(1, buffer56, 5_520); |
| } catch {} |
| let texture177 = device0.createTexture({ |
| size: {width: 1440, height: 2, depthOrArrayLayers: 109}, |
| dimension: '3d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder135.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| let bindGroup94 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 135, resource: textureView135}]}); |
| let buffer111 = device0.createBuffer({ |
| size: 140, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let textureView156 = texture141.createView({label: '\u397c\u0322\u0813\u97aa\u067b\u3704\u9ac8\u8737\u{1f6aa}\ueb1b', aspect: 'all'}); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({label: '\u048f\u958c\u99ca', colorFormats: ['r8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder122.setBindGroup(3, bindGroup65, new Uint32Array(2504), 300, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer65, 80); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(2, bindGroup56, new Uint32Array(3037), 1_507, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer40, 920); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(0, buffer55, 0, 95); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer111, 'uint32', 40, 8); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| await gc(); |
| let bindGroup95 = device0.createBindGroup({layout: bindGroupLayout17, entries: [{binding: 67, resource: textureView109}]}); |
| try { |
| computePassEncoder135.setBindGroup(2, bindGroup64, new Uint32Array(932), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 107, 4, 343_841_174); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(32, 236, 80, -2_041_956_872, 28_625_951); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(0, buffer23, 524, 258); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(0, bindGroup52, new Uint32Array(4005), 891, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView157 = texture92.createView({arrayLayerCount: 1}); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: false, stencilReadOnly: true}); |
| let renderBundle23 = renderBundleEncoder23.finish({}); |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup69, new Uint32Array(3461), 2_300, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer13, 'uint32', 4_200, 1_431); |
| } catch {} |
| document.body.prepend(canvas3); |
| let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} }); |
| let bindGroup96 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 135, resource: textureView135}]}); |
| let pipelineLayout20 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let texture178 = device0.createTexture({size: [600], dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_DST}); |
| let textureView158 = texture176.createView({}); |
| let sampler101 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 34.38, |
| lodMaxClamp: 43.73, |
| maxAnisotropy: 4, |
| }); |
| try { |
| renderPassEncoder8.draw(275, 4, 102_612_883, 433_856_675); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer99, 472); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(2, bindGroup55, new Uint32Array(403), 137, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(0, buffer30); |
| } catch {} |
| let buffer112 = device0.createBuffer({ |
| size: 7392, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder182 = device0.createCommandEncoder(); |
| let computePassEncoder136 = commandEncoder182.beginComputePass({}); |
| try { |
| computePassEncoder78.setBindGroup(1, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup95, new Uint32Array(4826), 629, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(143, 251, 8, -1_296_212_625, 2_085_299_476); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer102, 328); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer108, 56); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup39, new Uint32Array(18), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(3, buffer66, 2_744, 2_461); |
| } catch {} |
| try { |
| await shaderModule16.getCompilationInfo(); |
| } catch {} |
| try { |
| adapter0.label = '\u0f27\u0142\u1484\u06d4\u63bf'; |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({ |
| layout: bindGroupLayout22, |
| entries: [{binding: 91, resource: sampler69}, {binding: 1, resource: textureView52}], |
| }); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let querySet23 = device0.createQuerySet({type: 'occlusion', count: 532}); |
| let texture179 = device0.createTexture({ |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder29.setBindGroup(2, bindGroup31); |
| } catch {} |
| try { |
| computePassEncoder127.setBindGroup(3, bindGroup42, new Uint32Array(844), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup42, new Uint32Array(1868), 339, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 228, 0, 168_536_337); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(40, 17, 20, 1_180_569_805, 745_242_961); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer21, 1_000); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup56, new Uint32Array(253), 55, 0); |
| } catch {} |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let textureView159 = texture80.createView({label: '\u00b2\u0ffc\u0f15\u30f2\u871b\u511f\u5262\u3d2b\u015e\ubbb4\u{1fd6c}', arrayLayerCount: 1}); |
| let computePassEncoder137 = commandEncoder184.beginComputePass({}); |
| let renderPassEncoder46 = commandEncoder183.beginRenderPass({ |
| label: '\u8960\u0bf7\ucb0d\u{1ff9b}\u0989\u{1fbeb}\u0b45', |
| colorAttachments: [{ |
| view: textureView132, |
| depthSlice: 25, |
| clearValue: { r: 255.8, g: 581.4, b: -483.1, a: -831.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView128, |
| depthClearValue: -7.848998907749694, |
| depthLoadOp: 'load', |
| depthStoreOp: 'store', |
| stencilClearValue: 53812, |
| }, |
| }); |
| try { |
| computePassEncoder121.dispatchWorkgroupsIndirect(buffer68, 128); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(1, buffer111, 0, 19); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer53, 'uint16', 246, 718); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let bindGroup98 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 187, resource: textureView61}, |
| {binding: 184, resource: {buffer: buffer101, offset: 1792, size: 407}}, |
| ], |
| }); |
| let buffer113 = device0.createBuffer({ |
| size: 52244, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder185 = device0.createCommandEncoder({}); |
| let texture180 = device0.createTexture({ |
| size: [150, 24, 277], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder47 = commandEncoder185.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView115, |
| clearValue: { r: 824.1, g: -237.9, b: -357.7, a: -251.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder42.setBindGroup(2, bindGroup63, new Uint32Array(830), 203, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(295, 235, 396_855_274, 1_055_783_944); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer65, 684); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer26, 'uint32', 2_656, 209); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| let shaderModule17 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| /* target size: 114 max align: 2 */ |
| struct T0 { |
| @align(2) f0: array<array<vec2u, 1>, 6>, |
| @align(2) @size(16) f1: array<array<i32, 1>, 1>, |
| @size(50) f2: f16, |
| } |
| /* target size: 51 max align: 1 */ |
| struct T1 { |
| @align(1) f0: array<vec2h, 2>, |
| @align(1) f1: atomic<i32>, |
| @align(1) @size(8) f2: array<f32, 1>, |
| @align(1) f3: atomic<u32>, |
| @align(1) @size(27) f4: atomic<i32>, |
| } |
| /* target size: 16 max align: 16 */ |
| struct T2 { |
| @size(16) f0: array<vec2h, 1>, |
| } |
| @group(1) @binding(64) var<storage, read_write> buffer114: array<T1>; |
| @group(0) @binding(15) var tex9: texture_cube_array<f32>; |
| @group(0) @binding(374) var st37: texture_storage_2d<rgba16sint, read>; |
| @group(0) @binding(49) var st36: texture_storage_2d_array<r32float, write>; |
| @group(0) @binding(234) var sam9: sampler; |
| struct S5 { |
| @location(4) @interpolate(flat) f0: vec3f |
| } |
| struct S6 { |
| @location(8) f0: vec4u, |
| @location(5) f1: f32 |
| } |
| struct VertexOutput18 { |
| @builtin(position) f57: vec4f, |
| @location(2) @interpolate(perspective, sample) f58: vec2h, |
| @location(15) f59: f16, |
| @location(9) f60: vec4h, |
| @location(14) f61: vec4f, |
| @location(0) @interpolate(perspective, sample) f62: vec4f, |
| @location(1) @interpolate(flat) f63: u32 |
| } |
| |
| @vertex |
| fn vertex0(@builtin(instance_index) a0: u32, @location(7) a1: vec4h, @location(12) a2: vec2i, @location(14) a3: vec4u, @location(9) a4: vec2h, @location(13) a5: vec3f, a6: S5, @location(15) a7: vec2u, @location(0) a8: vec4f, @location(3) a9: vec4f, a10: S6, @location(1) a11: vec3f) -> VertexOutput18 { |
| var out: VertexOutput18; |
| _ = textureGather(0, tex9, sam9, vec3f(), 0); |
| _ = a3; |
| _ = a5; |
| out.f60 += vec4h(-55657.8); |
| return out; |
| } |
| struct S7 { |
| @builtin(local_invocation_index) f0: u32 |
| } |
| |
| @compute @workgroup_size(1, 1, 3) |
| fn compute0(a0: S7) { |
| _ = textureLoad(st37, vec2i()); |
| _ = buffer114[arrayLength(&buffer114)].f3; |
| _ = atomicExchange(&buffer114[arrayLength(&buffer114)].f1, 175); |
| if bool(atomicExchange(&buffer114[arrayLength(&buffer114)].f3, 95)) { |
| textureStore(st36, vec2i(), 0, vec4f(0.04195, 0.09704, 0.3255, 0.09194)); |
| } |
| }`, |
| hints: {}, |
| }); |
| let commandEncoder186 = device0.createCommandEncoder(); |
| let computePassEncoder138 = commandEncoder186.beginComputePass({}); |
| let renderBundle24 = renderBundleEncoder24.finish({}); |
| let sampler102 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.35, |
| compare: 'not-equal', |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder29.setBindGroup(2, bindGroup79); |
| } catch {} |
| try { |
| computePassEncoder83.setBindGroup(1, bindGroup80, new Uint32Array(2955), 98, 0); |
| } catch {} |
| try { |
| computePassEncoder136.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer65, 64); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer80, 352); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer68, 216, 844); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 360, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData18, |
| origin: { x: 1, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture87, |
| mipLevel: 2, |
| origin: {x: 142, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let texture181 = device0.createTexture({ |
| size: [164, 12, 1], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler103 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer53, 284); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer99, 888); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(3, buffer104, 260); |
| } catch {} |
| try { |
| window.someLabel = textureView49.label; |
| } catch {} |
| let commandEncoder188 = device0.createCommandEncoder({}); |
| let texture182 = device0.createTexture({label: '\ua703\uf375', size: [2, 2, 12], format: 'depth16unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder139 = commandEncoder188.beginComputePass({}); |
| let sampler104 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 64.64, |
| }); |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer45, 1_196); |
| } catch {} |
| try { |
| buffer77.unmap(); |
| } catch {} |
| try { |
| commandEncoder187.copyTextureToTexture({ |
| texture: texture88, |
| mipLevel: 0, |
| origin: {x: 45, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 55, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder187.clearBuffer(buffer75, 2544, 19892); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData30 = new ImageData(60, 16); |
| let bindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 106, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder189 = device0.createCommandEncoder({}); |
| let querySet24 = device0.createQuerySet({type: 'occlusion', count: 604}); |
| let texture183 = device0.createTexture({ |
| size: {width: 75, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView160 = texture129.createView({aspect: 'all', mipLevelCount: 1}); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthStencilFormat: 'depth16unorm', depthReadOnly: true}); |
| let renderBundle25 = renderBundleEncoder25.finish({}); |
| try { |
| computePassEncoder83.setBindGroup(0, bindGroup73, new Uint32Array(3744), 608, 0); |
| } catch {} |
| try { |
| computePassEncoder138.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder187.copyTextureToTexture({ |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture87, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 150, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup99 = device0.createBindGroup({ |
| layout: bindGroupLayout12, |
| entries: [ |
| {binding: 380, resource: textureView74}, |
| {binding: 17, resource: {buffer: buffer11, offset: 1536, size: 1942}}, |
| ], |
| }); |
| let commandEncoder190 = device0.createCommandEncoder({}); |
| let texture184 = device0.createTexture({ |
| size: {width: 82, height: 6, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder48 = commandEncoder187.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView85, |
| depthSlice: 2, |
| clearValue: { r: 498.9, g: -939.1, b: -434.3, a: -876.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet24, |
| }); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthReadOnly: true}); |
| try { |
| computePassEncoder99.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup61, new Uint32Array(5513), 1_784, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer59, 'uint16', 10, 61); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(4, buffer70); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup86, new Uint32Array(2109), 32, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer42, 'uint32', 84, 14); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline11); |
| } catch {} |
| let arrayBuffer15 = buffer25.getMappedRange(0, 28); |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 48, depthOrArrayLayers: 3} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 98, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder191 = device0.createCommandEncoder(); |
| let commandBuffer6 = commandEncoder190.finish({}); |
| let textureView161 = texture103.createView({dimension: 'cube', baseArrayLayer: 0}); |
| try { |
| computePassEncoder83.setBindGroup(0, bindGroup93); |
| } catch {} |
| try { |
| computePassEncoder94.setBindGroup(1, bindGroup6, new Uint32Array(313), 36, 0); |
| } catch {} |
| try { |
| computePassEncoder139.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(62, 460, 76, 6_838_698, 1_323_825_106); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer56, 3_196); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer68, 560); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let bindGroup100 = device0.createBindGroup({layout: bindGroupLayout2, entries: [{binding: 28, resource: {buffer: buffer94, offset: 1024}}]}); |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let textureView162 = texture176.createView({}); |
| let externalTexture17 = device0.importExternalTexture({source: video0}); |
| try { |
| computePassEncoder99.setBindGroup(2, bindGroup77, new Uint32Array(1230), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(3, bindGroup82, new Uint32Array(27), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle0, renderBundle21]); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(25, 37, 64, 467_492_531, 12_242_264); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer49, 536); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(0, buffer107, 0, 4_345); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(3, buffer3, 3_428, 75); |
| } catch {} |
| try { |
| commandEncoder189.copyBufferToBuffer(buffer87, 1724, buffer32, 412, 324); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let imageData31 = new ImageData(88, 72); |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| let texture185 = device0.createTexture({ |
| size: [150, 24, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder119.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(3, bindGroup21, new Uint32Array(1103), 540, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(0, 89, 0, 3_028_045_620); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer52, 8_176); |
| } catch {} |
| try { |
| renderPassEncoder39.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup97); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(7, buffer71, 0, 1_839); |
| } catch {} |
| try { |
| computePassEncoder58.insertDebugMarker('\ud765'); |
| } catch {} |
| let buffer115 = device0.createBuffer({size: 1026, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let textureView163 = texture36.createView({format: 'rgb10a2unorm', mipLevelCount: 1}); |
| let computePassEncoder140 = commandEncoder194.beginComputePass({}); |
| let renderBundle26 = renderBundleEncoder26.finish({}); |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup81, new Uint32Array(2789), 531, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(17, 48, 71, -1_884_009_760, 1_492_928_788); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer67, 2_984); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(0, buffer106); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder192.copyBufferToBuffer(buffer64, 12, buffer71, 312, 160); |
| } catch {} |
| let bindGroup101 = device0.createBindGroup({ |
| label: '\u7b87\u084f\u0943\u3702\u0c42\u7393\u{1fdc6}', |
| layout: bindGroupLayout21, |
| entries: [{binding: 102, resource: textureView58}], |
| }); |
| let commandEncoder195 = device0.createCommandEncoder({label: '\u0549\u0114\u0f1b\u02d0'}); |
| let texture186 = device0.createTexture({ |
| label: '\u43ee\ucb85', |
| size: [360, 1, 1], |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler105 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 17.09, |
| }); |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup55, new Uint32Array(2796), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer57, 972); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer91, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline4); |
| } catch {} |
| document.body.prepend(img4); |
| let buffer116 = device0.createBuffer({ |
| size: 5164, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let querySet25 = device0.createQuerySet({ |
| label: '\u7057\u6c66\u1cf6\u61e9\u3e5e\u00b3\u9d66\u03d8\u704a\u8e40\u7bcb', |
| type: 'occlusion', |
| count: 90, |
| }); |
| let textureView164 = texture157.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder140.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer26, 3_348); |
| } catch {} |
| try { |
| commandEncoder189.copyBufferToBuffer(buffer48, 1724, buffer26, 2412, 588); |
| } catch {} |
| let buffer117 = device0.createBuffer({ |
| size: 695, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture187 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView165 = texture126.createView({label: '\u1632\u0f76\u{1ff03}\u7a8a\u6598\u063b\u0420\u04d2'}); |
| let computePassEncoder141 = commandEncoder192.beginComputePass(); |
| let sampler106 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 69.20}); |
| try { |
| computePassEncoder137.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup38, new Uint32Array(223), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(197, 7, 184_372_188, 1_104_517_620); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer57, 96); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer103, 'uint32', 2_416, 1_940); |
| } catch {} |
| try { |
| commandEncoder189.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 380 */ |
| offset: 380, |
| buffer: buffer12, |
| }, { |
| texture: texture184, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder191.resolveQuerySet(querySet3, 318, 37, buffer68, 0); |
| } catch {} |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'jedecP22Phosphors', transfer: 'bt2020_10bit'} }); |
| let bindGroup102 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 80, resource: textureView13}]}); |
| let commandEncoder196 = device0.createCommandEncoder({label: '\u1e87\u5471\u{1ffc6}\ub178'}); |
| let computePassEncoder142 = commandEncoder195.beginComputePass({}); |
| try { |
| computePassEncoder142.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder18.end(); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer111, 'uint16', 18, 4); |
| } catch {} |
| try { |
| commandEncoder196.copyTextureToBuffer({ |
| texture: texture163, |
| mipLevel: 0, |
| origin: {x: 60, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 396 widthInBlocks: 99 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5664 */ |
| offset: 5664, |
| buffer: buffer69, |
| }, {width: 99, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup103 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 102, resource: textureView53}]}); |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let texture188 = device0.createTexture({ |
| size: {width: 360}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler107 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMinClamp: 98.20, |
| lodMaxClamp: 99.46, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(2, bindGroup48, new Uint32Array(1705), 445, 0); |
| } catch {} |
| try { |
| computePassEncoder141.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(93, 19, 563_520_447, 909_633_878); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(117, 77, 35, 33_839_671, 49_803_366); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer73, 6_300); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer41, 1_200); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder197.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 6380 */ |
| offset: 6380, |
| buffer: buffer87, |
| }, { |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder196.copyTextureToTexture({ |
| texture: texture142, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 5, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet26 = device0.createQuerySet({type: 'occlusion', count: 1678}); |
| let renderPassEncoder49 = commandEncoder191.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView99, |
| clearValue: { r: 114.0, g: -21.27, b: 31.69, a: 381.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet12, |
| }); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], sampleCount: 1, depthReadOnly: true}); |
| let renderBundle27 = renderBundleEncoder27.finish({}); |
| try { |
| renderPassEncoder3.drawIndexed(60, 169, 16, -2_108_393_607, 97_705_228); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer6]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let sampler108 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 21.73, |
| lodMaxClamp: 73.54, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder53.setBindGroup(3, bindGroup97); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup44, new Uint32Array(802), 105, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 52, 49, 40_703_315, 247_695_837); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(6, buffer104, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 5, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(393).fill(66), /* required buffer size: 393 */ |
| {offset: 393}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout21 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let texture189 = device0.createTexture({ |
| size: {width: 659, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder142.setBindGroup(0, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(1, bindGroup88, new Uint32Array(397), 295, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer117, 96); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline9); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| video0.width = 86; |
| let video5 = await videoWithData(40); |
| let commandEncoder199 = device0.createCommandEncoder({}); |
| let texture190 = device0.createTexture({ |
| size: {width: 164, height: 12, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup20, new Uint32Array(499), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.beginOcclusionQuery(53); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer1, 'uint16', 4_048, 8_761); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(3, buffer33, 0, 2_573); |
| } catch {} |
| try { |
| renderPassEncoder7.insertDebugMarker('\u{1f7d8}'); |
| } catch {} |
| let commandEncoder200 = device0.createCommandEncoder(); |
| let querySet27 = device0.createQuerySet({label: '\uc292\u72a9\u{1fe26}', type: 'occlusion', count: 6}); |
| let textureView166 = texture22.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let computePassEncoder143 = commandEncoder193.beginComputePass({}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup73, new Uint32Array(628), 29, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer60, 516); }; |
| } catch {} |
| try { |
| renderPassEncoder8.draw(13, 294, 577_696_721, 266_814_234); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(232, 30, 17, 1_001_884_785, 210_316_816); |
| } catch {} |
| try { |
| commandEncoder199.copyBufferToBuffer(buffer48, 268, buffer56, 432, 4660); |
| } catch {} |
| let buffer118 = device0.createBuffer({ |
| label: '\u260b\u08d7\ua1ad\ua6b9\u8021\u{1f6cd}\u0775\u3c76\uca5d', |
| size: 5181, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture191 = device0.createTexture({ |
| label: '\u{1fd68}\u0e4d', |
| size: {width: 659, height: 48, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView167 = texture130.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder144 = commandEncoder197.beginComputePass(); |
| let renderPassEncoder50 = commandEncoder189.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView132, |
| depthSlice: 474, |
| clearValue: { r: 170.2, g: -428.5, b: 66.60, a: 276.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView91, |
| depthClearValue: 0.6768138467556092, |
| depthLoadOp: 'clear', |
| depthStoreOp: 'discard', |
| stencilClearValue: 2234, |
| stencilReadOnly: false, |
| }, |
| occlusionQuerySet: querySet21, |
| maxDrawCount: 343938974, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer67, 352); }; |
| } catch {} |
| try { |
| computePassEncoder144.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(0, bindGroup102, []); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(69, 565, 381_083_708, 1_530_645_169); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer68, 132); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer86, 'uint32', 300, 1_453); |
| } catch {} |
| try { |
| commandEncoder200.copyTextureToBuffer({ |
| texture: texture130, |
| mipLevel: 0, |
| origin: {x: 12, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 114 widthInBlocks: 57 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5086 */ |
| offset: 5086, |
| buffer: buffer49, |
| }, {width: 57, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 438, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(112).fill(38), /* required buffer size: 112 */ |
| {offset: 112, bytesPerRow: 22}, {width: 1, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 360, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 95, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView168 = texture152.createView({label: '\u{1fb53}\u0d6f\u0994\u5e52\ub164', dimension: '2d-array'}); |
| let computePassEncoder145 = commandEncoder200.beginComputePass(); |
| let renderPassEncoder51 = commandEncoder196.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView127, |
| depthSlice: 376, |
| clearValue: { r: -87.73, g: 955.2, b: 320.5, a: -145.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 155528931, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer40, 4_940); }; |
| } catch {} |
| try { |
| commandEncoder199.copyBufferToBuffer(buffer18, 16, buffer9, 13360, 80); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let textureView169 = texture13.createView({}); |
| let renderPassEncoder52 = commandEncoder199.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView48, |
| depthSlice: 14, |
| clearValue: { r: 80.74, g: 418.9, b: -141.2, a: -497.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler109 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMinClamp: 49.47, |
| lodMaxClamp: 55.40, |
| }); |
| try { |
| computePassEncoder43.setBindGroup(3, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder122.setBindGroup(2, bindGroup65, new Uint32Array(5800), 253, 0); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(113, 314, 862_437_228, 223_497_879); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(12, 73, 40, 490_591_645, 429_665_489); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer17, 2_568); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer102, 'uint32', 2_180, 1_384); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder198.copyTextureToBuffer({ |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 114, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 104 widthInBlocks: 26 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 56 */ |
| offset: 56, |
| buffer: buffer29, |
| }, {width: 26, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder25.insertDebugMarker('\uf11c'); |
| } catch {} |
| let buffer119 = device0.createBuffer({ |
| size: 13574, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder201 = device0.createCommandEncoder(); |
| let textureView170 = texture28.createView({dimension: '2d-array'}); |
| let renderPassEncoder53 = commandEncoder201.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView149, |
| clearValue: { r: -723.6, g: 832.2, b: 934.4, a: 707.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| renderPassEncoder50.setBindGroup(2, bindGroup57, new Uint32Array(2199), 217, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(13, 65, 681_414_394, 496_349_995); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture167, |
| mipLevel: 1, |
| origin: {x: 34, y: 1, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(107_447).fill(250), /* required buffer size: 107_447 */ |
| {offset: 47, bytesPerRow: 450, rowsPerImage: 119}, {width: 75, height: 1, depthOrArrayLayers: 3}); |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpteRp431', transfer: 'logSqrt'} }); |
| let computePassEncoder146 = commandEncoder198.beginComputePass({}); |
| try { |
| computePassEncoder145.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder44.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(31, 23, 357_447_295, 499_511_281); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer40, 3_700); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer70, 540); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer110, 0, 924); |
| } catch {} |
| try { |
| device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); }); |
| } catch {} |
| video1.requestVideoFrameCallback((now, metadata) => { metadata.length = now; }); |
| let bindGroup104 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 64, resource: {buffer: buffer70, offset: 256, size: 444}}], |
| }); |
| let querySet28 = device0.createQuerySet({type: 'occlusion', count: 441}); |
| let sampler110 = device0.createSampler({ |
| label: '\u0f58\u0887\ud292', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 15.74, |
| }); |
| try { |
| computePassEncoder121.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder109.setBindGroup(1, bindGroup64, new Uint32Array(2906), 437, 0); |
| } catch {} |
| try { |
| computePassEncoder143.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup101, new Uint32Array(199), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(20, 25, 428_339_229, 1_518_920_828); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(29, 90, 23, 448_239_705, 404_363_605); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer51, 11_960); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(2, buffer75, 0); |
| } catch {} |
| let bindGroup105 = device0.createBindGroup({ |
| label: '\u0a3a\u{1fdfd}\ucb7b\u0eff\ueef7\ua539\uc509', |
| layout: bindGroupLayout16, |
| entries: [{binding: 73, resource: textureView108}, {binding: 92, resource: textureView165}], |
| }); |
| let buffer120 = device0.createBuffer({ |
| size: 12364, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder202 = device0.createCommandEncoder({label: '\u0597\u2cc8\ua854\u5d6d\uffab\u7e60\u0dd3\u04b9\u1b44'}); |
| let computePassEncoder147 = commandEncoder202.beginComputePass({}); |
| try { |
| renderPassEncoder49.beginOcclusionQuery(16); |
| } catch {} |
| try { |
| renderPassEncoder44.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(233, 30, 67_114_551, 373_842_346); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(4, 109, 84, -1_985_713_627, 248_752_830); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder203 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(23, 410, 590_267_197, 584_158_089); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(9, 125, 48, 732_854_452, 132_512_740); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer27, 332); |
| } catch {} |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer92, 'uint32', 1_372, 1_219); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, undefined, 170_048_980, 178_028_216); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'iec6196624'} }); |
| let commandEncoder204 = device0.createCommandEncoder({}); |
| let texture192 = device0.createTexture({ |
| size: [600, 96, 1], |
| mipLevelCount: 3, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder148 = commandEncoder203.beginComputePass({}); |
| try { |
| computePassEncoder148.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(0, bindGroup70, new Uint32Array(355), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.executeBundles([renderBundle25]); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(15, 110, 1_100_828_168, 302_823_810); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(5, 14, 12, 632_355_138, 147_563_201); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer38, 856); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(1, buffer39, 128); |
| } catch {} |
| try { |
| commandEncoder204.copyBufferToBuffer(buffer53, 48, buffer69, 764, 776); |
| } catch {} |
| let buffer121 = device0.createBuffer({size: 21180, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true}); |
| let textureView171 = texture92.createView({}); |
| let textureView172 = texture180.createView({mipLevelCount: 1}); |
| let computePassEncoder149 = commandEncoder204.beginComputePass({}); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder117.setBindGroup(0, bindGroup31, new Uint32Array(1472), 136, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(2, bindGroup54, new Uint32Array(1252), 171, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(73, 47, 141_833_159, 657_264_013); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer61, 1_912); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer53, 260); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline5); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| document.body.prepend(video4); |
| let bindGroup106 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 190, resource: textureView13}]}); |
| let buffer122 = device0.createBuffer({ |
| size: 1266, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler111 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.69, |
| maxAnisotropy: 15, |
| }); |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer27, 'uint16', 0, 185); |
| } catch {} |
| try { |
| renderPassEncoder53.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(4_294_967_295, undefined, 197_703_050, 261_377_630); |
| } catch {} |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt2020', transfer: 'log'} }); |
| let videoFrame29 = new VideoFrame(videoFrame19, {timestamp: 0}); |
| let commandEncoder205 = device0.createCommandEncoder(); |
| let textureView173 = texture185.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder150 = commandEncoder205.beginComputePass({}); |
| try { |
| computePassEncoder124.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(0, bindGroup52, []); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer105, 768); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline5); |
| } catch {} |
| let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'jedecP22Phosphors', transfer: 'bt709'} }); |
| let texture193 = device0.createTexture({ |
| label: '\u{1f845}\u{1f6c9}\u4cb8\u0c75\u47b9\udeea\u5db0\ud429\uf45d', |
| size: {width: 82}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler112 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 35.91, |
| lodMaxClamp: 87.76, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup94, new Uint32Array(70), 30, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer78, 5_468); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(5, buffer71); |
| } catch {} |
| let imageData32 = new ImageData(20, 36); |
| let texture194 = device0.createTexture({ |
| size: [75, 12, 1], |
| sampleCount: 4, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView174 = texture107.createView({label: '\u{1febf}\uf7dd\u16f6\u2534', mipLevelCount: 1}); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(48, 248, 62, 498_356_878, 549_009_938); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer113, 1_660); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer42, 20); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(3, buffer68, 332); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 5208, new Float32Array(11864), 3875, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2880, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame19, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 346, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(video2); |
| let bindGroup107 = device0.createBindGroup({ |
| label: '\u0f4a\uaa25\u062f\u94ff\ud876\u010d\u7c1d', |
| layout: bindGroupLayout6, |
| entries: [{binding: 64, resource: {buffer: buffer94, offset: 2560}}], |
| }); |
| let querySet29 = device0.createQuerySet({type: 'occlusion', count: 169}); |
| let sampler113 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 92.91, |
| lodMaxClamp: 95.32, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(28, 62, 609_760_923, 349_979_774); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer60, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer67, 'uint32', 4_516, 3_408); |
| } catch {} |
| try { |
| renderPassEncoder53.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 24, depthOrArrayLayers: 15} |
| */ |
| { |
| source: img2, |
| origin: { x: 3, y: 13 }, |
| flipY: false, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: {x: 29, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 8, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer123 = device0.createBuffer({ |
| size: 18064, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler114 = device0.createSampler({ |
| label: '\u09d1\u12c6', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 93.20, |
| compare: 'equal', |
| }); |
| try { |
| computePassEncoder77.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder95.setBindGroup(3, bindGroup41, new Uint32Array(3752), 1_964, 0); |
| } catch {} |
| try { |
| computePassEncoder149.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder52.setScissorRect(0, 4, 137, 4); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(126, 243, 157, -2_052_349_278, 26_989_632); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer60, 364); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer105, 'uint16', 736, 1_032); |
| } catch {} |
| let bindGroup108 = device0.createBindGroup({layout: bindGroupLayout18, entries: [{binding: 135, resource: textureView112}]}); |
| let texture195 = device0.createTexture({ |
| size: {width: 164, height: 12, depthOrArrayLayers: 166}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder71.setBindGroup(1, bindGroup80, []); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(185, 364, 108_425_442, 341_326_392); |
| } catch {} |
| let imageData33 = new ImageData(12, 28); |
| let pipelineLayout22 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout22]}); |
| let buffer124 = device0.createBuffer({ |
| size: 29016, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder206 = device0.createCommandEncoder({}); |
| let textureView175 = texture152.createView({}); |
| let renderPassEncoder54 = commandEncoder206.beginRenderPass({ |
| colorAttachments: [{view: textureView173, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet21, |
| }); |
| let sampler115 = device0.createSampler({ |
| label: '\u{1fe9b}\u0f12\uc2cb\u1d8a', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 54.45, |
| lodMaxClamp: 73.25, |
| }); |
| try { |
| computePassEncoder14.dispatchWorkgroups(2); |
| } catch {} |
| try { |
| computePassEncoder147.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup95, new Uint32Array(2689), 98, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle18, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(101, 46, 2_179_911_616, 2_221_879_927); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer108, 216); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer103, 2_232); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder128.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup98, new Uint32Array(548), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer8, 488); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer13, 'uint16', 2_104, 6_628); |
| } catch {} |
| let pipeline12 = await device0.createComputePipelineAsync({layout: pipelineLayout5, compute: {module: shaderModule16, constants: {}}}); |
| let commandEncoder207 = device0.createCommandEncoder({}); |
| let textureView176 = texture122.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let computePassEncoder151 = commandEncoder207.beginComputePass({}); |
| let sampler116 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 51.37, |
| lodMaxClamp: 78.23, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer51, 3_840); }; |
| } catch {} |
| try { |
| computePassEncoder151.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder38.setViewport(257.2873122841211, 15.705347614957297, 11.289603900673288, 16.382863046754846, 0.01804777971533389, 0.5002700254910066); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(10, 17, 447_807_905, 871_855_353); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder208 = device0.createCommandEncoder({}); |
| let textureView177 = texture185.createView({label: '\u2018\u0c23\u4d42\u{1ff10}', dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder152 = commandEncoder208.beginComputePass(); |
| try { |
| computePassEncoder150.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder30.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder24.setBlendConstant({ r: -814.5, g: 163.1, b: 337.3, a: 836.2, }); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(117, 74, 351_630_397, 1_921_398_167); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(40, 29, 61, 381_054_685, 535_213_943); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer104, 632); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer56, 5_640); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(5, buffer73, 0, 13_952); |
| } catch {} |
| let arrayBuffer16 = buffer66.getMappedRange(0, 1600); |
| let commandEncoder209 = device0.createCommandEncoder(); |
| let commandBuffer7 = commandEncoder209.finish(); |
| let texture196 = device0.createTexture({ |
| size: [600, 96, 1], |
| sampleCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup43, new Uint32Array(4136), 229, 0); |
| } catch {} |
| try { |
| computePassEncoder152.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(24, 816, 24, 396_729_820, 1_252_507_971); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer116, 'uint32', 60, 264); |
| } catch {} |
| try { |
| buffer16.unmap(); |
| } catch {} |
| document.body.append(img1); |
| video0.height = 86; |
| let bindGroup109 = device0.createBindGroup({ |
| layout: bindGroupLayout16, |
| entries: [{binding: 92, resource: textureView103}, {binding: 73, resource: textureView108}], |
| }); |
| let pipelineLayout23 = device0.createPipelineLayout({label: '\u{1fc1f}\u{1fb0b}\u{1f76b}\u{1f69f}\u2ff3\ufdc3\u20de\ua040\u091c', bindGroupLayouts: []}); |
| let buffer125 = device0.createBuffer({ |
| label: '\u43b4\u0342\u0d3e\uc6a6\ucf28\u{1fd1c}\u0632\u0b6b\u{1f6ea}\u0859\u8894', |
| size: 48, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder210 = device0.createCommandEncoder({label: '\u0be6\u4238\ub7b2\u04b7\uc53a\u0e21'}); |
| let textureView178 = texture196.createView({aspect: 'all'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer119, 188); }; |
| } catch {} |
| try { |
| computePassEncoder121.end(); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup96, new Uint32Array(2066), 252, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer51, 532); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer103, 2_748); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(5, buffer30, 12_960, 22_112); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| try { |
| commandEncoder160.copyBufferToBuffer(buffer16, 1692, buffer33, 11140, 1276); |
| } catch {} |
| try { |
| commandEncoder210.clearBuffer(buffer38, 1564, 112); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7]); |
| } catch {} |
| let bindGroup110 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 102, resource: textureView55}]}); |
| let sampler117 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 36.37, |
| lodMaxClamp: 60.62, |
| compare: 'equal', |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder146.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer27, 180); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer102, 2_936); |
| } catch {} |
| try { |
| renderPassEncoder52.setVertexBuffer(0, buffer102, 792, 2_862); |
| } catch {} |
| try { |
| commandEncoder210.copyTextureToBuffer({ |
| texture: texture185, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 34 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 451 */ |
| offset: 451, |
| buffer: buffer117, |
| }, {width: 34, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline13 = device0.createComputePipeline({layout: pipelineLayout5, compute: {module: shaderModule16, constants: {}}}); |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let img5 = await imageWithData(3, 44, '#10101010', '#20202020'); |
| let bindGroup111 = device0.createBindGroup({layout: bindGroupLayout17, entries: [{binding: 67, resource: textureView123}]}); |
| let computePassEncoder153 = commandEncoder160.beginComputePass({label: '\u6903\u7362\u{1f8c6}\udf1c\u3e66\u60d5\u01e1'}); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup74, new Uint32Array(318), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer119, 1_208); |
| } catch {} |
| let arrayBuffer17 = buffer108.getMappedRange(72); |
| try { |
| device0.queue.writeBuffer(buffer13, 7564, new Int16Array(40638), 9540, 128); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup112 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView32}]}); |
| let computePassEncoder154 = commandEncoder210.beginComputePass({label: '\u338a\u0e8c\u6bbb\u{1f71a}\uc62d\u0b4d\u653c\u0357\u05b3\u86cb'}); |
| try { |
| computePassEncoder128.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer58, 0, 223); |
| } catch {} |
| let texture197 = device0.createTexture({ |
| label: '\u0e03\u0764\u0e88\ud33d\u0bc0\ua0e8\u0047', |
| size: {width: 75, height: 12, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder153.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder40.setViewport(26.94324888660311, 16.541668308863883, 53.587543902223445, 2.111123873773678, 0.24433556713611082, 0.5910652555936265); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(160, 75, 232, 509_420_221, 458_033_835); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer117, 88); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(5, buffer102, 352); |
| } catch {} |
| document.body.append(canvas3); |
| let bindGroup113 = device0.createBindGroup({ |
| layout: bindGroupLayout10, |
| entries: [ |
| {binding: 169, resource: textureView76}, |
| {binding: 139, resource: textureView56}, |
| {binding: 3, resource: textureView130}, |
| {binding: 83, resource: {buffer: buffer4, offset: 5888, size: 6664}}, |
| {binding: 78, resource: textureView56}, |
| {binding: 633, resource: textureView89}, |
| {binding: 41, resource: textureView79}, |
| {binding: 444, resource: textureView58}, |
| {binding: 335, resource: textureView52}, |
| {binding: 80, resource: textureView131}, |
| {binding: 130, resource: {buffer: buffer64, offset: 0}}, |
| ], |
| }); |
| let texture198 = device0.createTexture({ |
| label: '\u0ff5\u31d6\u826b\u25a8\u96c1\u8f0f\u9aae\u7a89\u{1fcf7}', |
| size: {width: 600, height: 96, depthOrArrayLayers: 866}, |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder109.setBindGroup(3, bindGroup85, new Uint32Array(933), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(29, 1_000, 275_086_671, 215_245_743); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer70, 268); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let querySet30 = device0.createQuerySet({type: 'occlusion', count: 456}); |
| let sampler118 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'clamp-to-edge', minFilter: 'nearest', lodMaxClamp: 94.30}); |
| try { |
| computePassEncoder125.setBindGroup(2, bindGroup0, new Uint32Array(1523), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(2, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(2, 66, 168_368_401, 120_311_424); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer26, 3_212); |
| } catch {} |
| try { |
| renderPassEncoder45.setPipeline(pipeline9); |
| } catch {} |
| let arrayBuffer18 = buffer65.getMappedRange(); |
| try { |
| computePassEncoder48.pushDebugGroup('\u2969'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| document.body.prepend(video5); |
| let imageBitmap3 = await createImageBitmap(video5); |
| try { |
| computePassEncoder101.setBindGroup(3, bindGroup52, new Uint32Array(74), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(1, bindGroup96); |
| } catch {} |
| try { |
| renderPassEncoder35.beginOcclusionQuery(50); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(176, 122, 2_032_106_137, 471_829_706); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer52, 6_648); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(0, buffer73, 3_128, 8_770); |
| } catch {} |
| document.body.prepend(video2); |
| let bindGroup114 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView32}]}); |
| let texture199 = device0.createTexture({ |
| size: [659, 48, 1], |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder91.setBindGroup(1, bindGroup106, new Uint32Array(502), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup98); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer21, 140); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer102, 'uint32', 816, 2_112); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(6, buffer35, 296, 103); |
| } catch {} |
| let arrayBuffer19 = buffer111.getMappedRange(); |
| try { |
| computePassEncoder48.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 47, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(672).fill(202), /* required buffer size: 672 */ |
| {offset: 672, bytesPerRow: 96, rowsPerImage: 20}, {width: 5, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| canvas3.width = 106; |
| await gc(); |
| try { |
| adapter0.label = '\u824e\u662e\u786b\u3fa8\u054d\u59b7\u0e6f\u{1f82e}\ue300\u{1f705}'; |
| } catch {} |
| let commandEncoder211 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder89.setBindGroup(0, bindGroup57); |
| } catch {} |
| try { |
| computePassEncoder154.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup24, new Uint32Array(1778), 787, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer33, 2_020); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer17, 1_244); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(3, buffer123, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { log('device0 lost!'); log(message, reason); }); |
| } catch {} |
| try { |
| await buffer90.mapAsync(GPUMapMode.READ, 0, 44); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['stencil8'], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let bindGroup115 = device0.createBindGroup({ |
| label: '\u3d24\u6eed\u37de', |
| layout: bindGroupLayout12, |
| entries: [ |
| {binding: 17, resource: {buffer: buffer20, offset: 1280, size: 9089}}, |
| {binding: 380, resource: textureView175}, |
| ], |
| }); |
| let querySet31 = device0.createQuerySet({ |
| label: '\ued3f\u4593\u0c1b\udc77\u{1ffa8}\u{1ff41}\u9cb7\u0f30\u0d46\u141f', |
| type: 'occlusion', |
| count: 386, |
| }); |
| let texture200 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView179 = texture58.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let sampler119 = device0.createSampler({ |
| label: '\u5768\u266f\u{1fc7c}\u0ab7\u{1f6a4}\u1aad\ua704\uea2b\ueb21\u23a4', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 87.08, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder131.setBindGroup(1, bindGroup103); |
| } catch {} |
| try { |
| renderPassEncoder31.executeBundles([renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer60, 1_404); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer67, 3_296); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(1, buffer101, 2_852); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer120, 452, new BigUint64Array(65)); |
| } catch {} |
| let commandEncoder212 = device0.createCommandEncoder({}); |
| let computePassEncoder155 = commandEncoder212.beginComputePass(); |
| try { |
| computePassEncoder144.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer40, 2_416); }; |
| } catch {} |
| try { |
| computePassEncoder155.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup81, []); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(2, bindGroup73, new Uint32Array(425), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(11, 192, 315_876_455, 1_477_895_368); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(86, 275, 22, -1_922_348_164, 566_520_486); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer82, 1_524); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer111, 'uint32', 104, 4); |
| } catch {} |
| let arrayBuffer20 = buffer99.getMappedRange(0, 268); |
| let bindGroup116 = device0.createBindGroup({layout: bindGroupLayout21, entries: [{binding: 102, resource: textureView179}]}); |
| let buffer126 = device0.createBuffer({ |
| size: 36214, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder213 = device0.createCommandEncoder({}); |
| let texture201 = device0.createTexture({ |
| size: {width: 659, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder156 = commandEncoder211.beginComputePass({}); |
| try { |
| renderPassEncoder22.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(500, 218, 1_126_079_279, 39_972_574); |
| } catch {} |
| let arrayBuffer21 = buffer112.getMappedRange(88, 1980); |
| try { |
| commandEncoder213.copyBufferToTexture({ |
| /* bytesInLastRow: 208 widthInBlocks: 26 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 4672 */ |
| offset: 4672, |
| buffer: buffer12, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 26, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder213.copyTextureToBuffer({ |
| texture: texture69, |
| mipLevel: 2, |
| origin: {x: 361, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 352 widthInBlocks: 88 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2484 */ |
| offset: 2484, |
| rowsPerImage: 212, |
| buffer: buffer33, |
| }, {width: 88, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer127 = device0.createBuffer({ |
| size: 21184, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder214 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder105.setBindGroup(0, bindGroup27, []); |
| } catch {} |
| try { |
| computePassEncoder156.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(67, 51, 577_796_766, 268_487_909); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(165, 67, 31, 113_752_921, 5_039_558); |
| } catch {} |
| try { |
| renderPassEncoder39.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| try { |
| computePassEncoder127.insertDebugMarker('\ua672'); |
| } catch {} |
| let buffer128 = device0.createBuffer({ |
| size: 9391, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder54.beginOcclusionQuery(31); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(130, 321, 12, -2_126_056_023, 610_077_555); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer40, 176); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer106, 'uint32', 388, 4_786); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(4_294_967_294, undefined, 0, 2_207_632_775); |
| } catch {} |
| await gc(); |
| let texture202 = device0.createTexture({ |
| label: '\u{1f942}\u{1f66f}\ud657\u5867\u345b', |
| size: [1440, 2, 1], |
| mipLevelCount: 4, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler120 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| lodMinClamp: 46.24, |
| lodMaxClamp: 64.08, |
| compare: 'always', |
| }); |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer102, 20); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer108, 168); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(2, buffer3, 0, 632); |
| } catch {} |
| let buffer129 = device0.createBuffer({ |
| size: 36851, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder215 = device0.createCommandEncoder({}); |
| let texture203 = device0.createTexture({size: [150], dimension: '1d', format: 'r8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let computePassEncoder157 = commandEncoder214.beginComputePass(); |
| try { |
| computePassEncoder99.setBindGroup(0, bindGroup65, new Uint32Array(3132), 407, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer101, 1_424); }; |
| } catch {} |
| try { |
| computePassEncoder157.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(5, 142, 836_255_791, 370_543_548); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(5, 450, 10, 274_554_026, 313_778_474); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer113, 'uint16', 2_164, 8_433); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(7, buffer112, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture64, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(543).fill(75), /* required buffer size: 543 */ |
| {offset: 543, bytesPerRow: 157, rowsPerImage: 34}, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer130 = device0.createBuffer({ |
| label: '\u09c4\u5b3a\u0445\u39b0\u063c\u{1f644}\u0ed3\u42b1', |
| size: 10324, |
| usage: GPUBufferUsage.MAP_READ, |
| }); |
| let querySet32 = device0.createQuerySet({type: 'occlusion', count: 446}); |
| let renderPassEncoder55 = commandEncoder213.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView132, |
| depthSlice: 124, |
| clearValue: { r: -319.0, g: 809.2, b: -801.6, a: -398.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| depthStencilAttachment: { |
| view: textureView91, |
| depthClearValue: 4.513340206536039, |
| depthReadOnly: true, |
| stencilClearValue: 18185, |
| stencilReadOnly: false, |
| }, |
| }); |
| try { |
| renderPassEncoder3.drawIndexed(56, 71, 62, 464_209_829, 1_264_975_126); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer107, 1_160); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 360, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 69, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| try { |
| computePassEncoder82.setBindGroup(2, bindGroup114, new Uint32Array(4682), 1_469, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.setBindGroup(3, bindGroup99, []); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup1, new Uint32Array(523), 166, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.executeBundles([renderBundle25, renderBundle22, renderBundle25, renderBundle25, renderBundle22, renderBundle22, renderBundle22]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 94, 1, 213_392_876); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer72, 100); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer68, 'uint16', 10, 56); |
| } catch {} |
| try { |
| commandEncoder215.copyBufferToBuffer(buffer112, 384, buffer5, 184, 4); |
| } catch {} |
| let offscreenCanvas4 = new OffscreenCanvas(21, 22); |
| let texture204 = device0.createTexture({size: {width: 164}, dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let renderPassEncoder56 = commandEncoder215.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView127, |
| depthSlice: 105, |
| clearValue: { r: -273.9, g: -255.3, b: -544.7, a: 946.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet9, |
| }); |
| try { |
| renderPassEncoder7.draw(37, 4, 43_757_330, 490_923_937); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 16, 3, 31_213_890, 2_168_264_350); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer72, 84); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer50, 'uint16', 2_592, 6_052); |
| } catch {} |
| let gpuCanvasContext7 = offscreenCanvas4.getContext('webgpu'); |
| document.body.prepend(canvas0); |
| offscreenCanvas3.width = 1453; |
| let promise22 = adapter0.requestAdapterInfo(); |
| let buffer131 = device0.createBuffer({ |
| size: 3740, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: true, |
| }); |
| let texture205 = device0.createTexture({ |
| size: [150, 24, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView180 = texture181.createView({dimension: '2d-array', format: 'rgba32float'}); |
| let sampler121 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 25.89, |
| lodMaxClamp: 74.97, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder77.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder125.setBindGroup(1, bindGroup46, new Uint32Array(877), 58, 0); |
| } catch {} |
| try { |
| renderPassEncoder54.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer16, 884); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(6, buffer47, 0, 31); |
| } catch {} |
| let commandEncoder216 = device0.createCommandEncoder(); |
| let texture206 = device0.createTexture({ |
| size: [2, 2, 12], |
| sampleCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup108, new Uint32Array(115), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setViewport(79.23516394473455, 24.110448571092054, 56.350454707932116, 8.536787192871614, 0.726584555244047, 0.9605764349779561); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer126, 'uint16', 4_072, 1_349); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let commandEncoder217 = device0.createCommandEncoder(); |
| let sampler122 = device0.createSampler({ |
| label: '\u{1fb9f}\ufdfd\u{1f836}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 68.32, |
| lodMaxClamp: 98.64, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder52.setBindGroup(3, bindGroup99); |
| } catch {} |
| try { |
| renderPassEncoder31.setScissorRect(0, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 411, 0, 336_778_222); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer115, 'uint32', 92, 120); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer113, 18_380); |
| } catch {} |
| try { |
| buffer83.unmap(); |
| } catch {} |
| try { |
| commandEncoder217.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1488 */ |
| offset: 1488, |
| buffer: buffer48, |
| }, { |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 55, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 390, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup117 = device0.createBindGroup({layout: bindGroupLayout9, entries: [{binding: 92, resource: textureView166}]}); |
| let texture207 = device0.createTexture({ |
| size: [164, 12, 177], |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView181 = texture175.createView({format: 'depth16unorm'}); |
| let computePassEncoder158 = commandEncoder217.beginComputePass({label: '\u1f63\u{1fd29}\u{1f7b0}\u{1f886}\u{1fdc6}\uda86\u{1f785}\ua83f\u4573\u{1fdb3}'}); |
| let sampler123 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 10.29, |
| compare: 'less-equal', |
| }); |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup116, []); |
| } catch {} |
| try { |
| renderPassEncoder50.setStencilReference(875); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(52, 80, 6_584_394, 1_782_489_973); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer41, 1_408); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer27, 44); |
| } catch {} |
| try { |
| commandEncoder216.resolveQuerySet(querySet3, 252, 9, buffer99, 256); |
| } catch {} |
| let bindGroup118 = device0.createBindGroup({ |
| label: '\u{1fe5a}\u44fe\u{1f8b9}\ueef6', |
| layout: bindGroupLayout5, |
| entries: [{binding: 598, resource: {buffer: buffer120, offset: 512}}], |
| }); |
| let buffer132 = device0.createBuffer({ |
| size: 10750, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder218 = device0.createCommandEncoder({}); |
| let sampler124 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 9.134, |
| lodMaxClamp: 11.96, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| computePassEncoder158.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(3, 110, 197_914_108, 900_970_537); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer119, 4_076); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline9); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); }; |
| } catch {} |
| try { |
| adapter0.label = '\u9a06\u0d06\u0a73\u{1f86a}\u0af9\u51d8\u0ea1\ud254\u0921'; |
| } catch {} |
| let textureView182 = texture109.createView({baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(0, bindGroup78); |
| } catch {} |
| try { |
| renderPassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(124, 134, 2_084_033_300, 133_961_451); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(11, 17, 0, -1_840_213_231, 654_011_236); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder89.setBindGroup(2, bindGroup110, new Uint32Array(199), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer82, 796); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer42, 0); |
| } catch {} |
| try { |
| commandEncoder218.copyTextureToBuffer({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 19, y: 12, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2893 */ |
| offset: 2893, |
| bytesPerRow: 256, |
| rowsPerImage: 451, |
| buffer: buffer32, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas2); |
| let renderPassEncoder57 = commandEncoder216.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView86, |
| clearValue: { r: 671.9, g: -572.8, b: 457.7, a: 175.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 194670359, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup41, []); |
| } catch {} |
| try { |
| renderPassEncoder54.setBindGroup(2, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder35.endOcclusionQuery(); |
| } catch {} |
| try { |
| buffer81.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| video3.requestVideoFrameCallback((now, metadata) => { metadata.length = now; }); |
| let buffer133 = device0.createBuffer({ |
| size: 7014, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandBuffer8 = commandEncoder218.finish(); |
| let sampler125 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 59.33, |
| lodMaxClamp: 82.30, |
| }); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame10}); |
| try { |
| computePassEncoder154.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer27, 12); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline9); |
| } catch {} |
| try { |
| computePassEncoder71.pushDebugGroup('\u127c'); |
| } catch {} |
| let buffer134 = device0.createBuffer({ |
| label: '\u0271\u{1fc81}\u0bb0\u0382\u0c0d\u0d30\u0129\u005d', |
| size: 13408, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture208 = device0.createTexture({ |
| size: {width: 1440, height: 2, depthOrArrayLayers: 1}, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView183 = texture71.createView({dimension: '2d-array'}); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthStencilFormat: 'depth16unorm'}); |
| try { |
| renderPassEncoder8.draw(230, 103, 162_948_332, 379_723_261); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(508, 64, 71, -1_961_846_575, 646_723_345); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer42, 44); |
| } catch {} |
| try { |
| renderPassEncoder40.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer129, 8_016, 468); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(3, bindGroup16, new Uint32Array(927), 26, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder219 = device0.createCommandEncoder({}); |
| let sampler126 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 36.38, |
| maxAnisotropy: 18, |
| }); |
| try { |
| renderPassEncoder44.setBindGroup(2, bindGroup12, new Uint32Array(440), 226, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.executeBundles([renderBundle27, renderBundle27, renderBundle8, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(95, 91, 84, 115_162_116, 110_823_518); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer117, 460); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(1, buffer102, 696, 1_853); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(2, bindGroup48, new Uint32Array(1563), 247, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer97, 'uint16', 88, 30); |
| } catch {} |
| await gc(); |
| let computePassEncoder159 = commandEncoder219.beginComputePass({}); |
| let renderBundle28 = renderBundleEncoder28.finish({label: '\u3b61\ua4e6\uff13\u5904\u{1fa61}\u{1f8fc}\ud43a\ud916'}); |
| try { |
| computePassEncoder159.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup82, new Uint32Array(3574), 825, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(118, 236, 9, -1_781_065_006, 331_780_753); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer102, 2_224); |
| } catch {} |
| let commandEncoder220 = device0.createCommandEncoder({}); |
| let texture209 = device0.createTexture({size: [75, 12, 1], mipLevelCount: 2, format: 'rgb10a2unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let computePassEncoder160 = commandEncoder220.beginComputePass({}); |
| let sampler127 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 75.61, |
| lodMaxClamp: 97.98, |
| }); |
| try { |
| computePassEncoder53.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(17, 24, 1_148_190_009, 1_119_985_374); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer127, 'uint16', 310, 463); |
| } catch {} |
| let pipeline14 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| multisample: {mask: 0xe979fee}, |
| fragment: { |
| module: shaderModule13, |
| targets: [{ |
| format: 'bgra8unorm-srgb', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 220, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x2', offset: 32, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 24, shaderLocation: 14}, |
| {format: 'float16x4', offset: 32, shaderLocation: 7}, |
| {format: 'float16x2', offset: 76, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 20, shaderLocation: 6}, |
| {format: 'sint32', offset: 20, shaderLocation: 2}, |
| {format: 'sint8x4', offset: 24, shaderLocation: 0}, |
| {format: 'snorm8x4', offset: 44, shaderLocation: 8}, |
| {format: 'float32x3', offset: 56, shaderLocation: 4}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 4, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 440, |
| stepMode: 'vertex', |
| attributes: [{format: 'float32x2', offset: 56, shaderLocation: 15}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32'}, |
| }); |
| try { |
| await promise22; |
| } catch {} |
| let externalTexture19 = device0.importExternalTexture({label: '\u{1fb0f}\u203c\u48b4\uadbc\u4ced', source: video4}); |
| try { |
| computePassEncoder137.setBindGroup(0, bindGroup31, new Uint32Array(1084), 252, 0); |
| } catch {} |
| try { |
| computePassEncoder26.dispatchWorkgroupsIndirect(buffer108, 420); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(142, 164, 190_897_911, 198_611_664); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(25, 161, 82, 932_607_547, 311_620_417); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer126, 'uint16', 8_062, 1_010); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline9); |
| } catch {} |
| try { |
| if (!arrayBuffer20.detached) { new Uint8Array(arrayBuffer20).fill(0x55); }; |
| } catch {} |
| let buffer135 = device0.createBuffer({size: 8767, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| try { |
| renderPassEncoder31.executeBundles([renderBundle18, renderBundle3, renderBundle21, renderBundle24, renderBundle24, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(261, 9, 128_290_854, 210_832_363); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer129, 2_424); |
| } catch {} |
| let buffer136 = device0.createBuffer({size: 7185, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture210 = device0.createTexture({ |
| size: [720, 1, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView184 = texture114.createView({dimension: '1d', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(1, bindGroup30, new Uint32Array(1167), 133, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(160, 492, 254_824_496, 209_169_738); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(7, 157, 7, 582_513_837, 222_381_045); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer65, 460); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(4, buffer106); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let bindGroup119 = device0.createBindGroup({layout: bindGroupLayout25, entries: [{binding: 106, resource: textureView74}]}); |
| let commandEncoder221 = device0.createCommandEncoder({}); |
| let texture211 = device0.createTexture({ |
| size: [659, 48, 1], |
| sampleCount: 4, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer49, 14_716); |
| } catch {} |
| try { |
| renderPassEncoder51.setPipeline(pipeline9); |
| } catch {} |
| let arrayBuffer22 = buffer74.getMappedRange(0, 708); |
| try { |
| device0.queue.writeBuffer(buffer43, 3620, new Float32Array(11193), 1588, 576); |
| } catch {} |
| let computePassEncoder161 = commandEncoder221.beginComputePass({label: '\u91ca\udb96\u26b4\ub028\u0cb3\u08b4\u{1faaf}\u304e'}); |
| let sampler128 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| minFilter: 'linear', |
| lodMinClamp: 51.68, |
| lodMaxClamp: 97.88, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder160.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 102, 1, 517_351_522); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(1, 177, 324, 537_615_793, 95_260_163); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer65, 316); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(6, buffer56, 0, 340); |
| } catch {} |
| try { |
| computePassEncoder131.insertDebugMarker('\uc0fa'); |
| } catch {} |
| let buffer137 = device0.createBuffer({size: 1853, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture212 = gpuCanvasContext2.getCurrentTexture(); |
| let sampler129 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 17.40, |
| }); |
| try { |
| computePassEncoder161.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(2, bindGroup49, new Uint32Array(1260), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setStencilReference(318); |
| } catch {} |
| let pipelineLayout24 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let querySet33 = device0.createQuerySet({type: 'occlusion', count: 518}); |
| let texture213 = device0.createTexture({size: {width: 300}, dimension: '1d', format: 'r16sint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder104.setBindGroup(1, bindGroup36, new Uint32Array(1380), 689, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer132, 2_660); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(0, buffer118); |
| } catch {} |
| let pipelineLayout25 = device0.createPipelineLayout({label: '\u0404\u495a\u0342\uaa75\u2ff5\u4607', bindGroupLayouts: []}); |
| let buffer138 = device0.createBuffer({ |
| size: 20017, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder222 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder50.setBindGroup(1, bindGroup10, new Uint32Array(1753), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(5, 450, 2, -1_841_366_535, 101_450_814); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer17, 736); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer126, 'uint32', 13_136, 3_135); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'srgb'}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture214 = device0.createTexture({ |
| size: {width: 75, height: 12, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView185 = texture83.createView({dimension: '3d', mipLevelCount: 1}); |
| let renderPassEncoder58 = commandEncoder222.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView183, |
| clearValue: { r: -447.8, g: -479.4, b: -861.7, a: -841.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet8, |
| maxDrawCount: 115820723, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer61, 148); }; |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(89, 84, 159, -1_985_069_924, 224_994_655); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer57, 568); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer51, 6_624); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline4); |
| } catch {} |
| let bindGroup120 = device0.createBindGroup({ |
| layout: bindGroupLayout15, |
| entries: [{binding: 92, resource: {buffer: buffer39, offset: 0, size: 1176}}], |
| }); |
| try { |
| computePassEncoder126.setBindGroup(1, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(1, bindGroup105); |
| } catch {} |
| try { |
| renderPassEncoder47.executeBundles([renderBundle7, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(48, 294, 11, 450_313_323, 84_641_714); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer120, 1_768); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 488, new DataView(new ArrayBuffer(4933)), 1230, 24); |
| } catch {} |
| let bindGroupLayout27 = device0.createBindGroupLayout({ |
| label: '\uf7f9\u03af\u{1fd15}\ub783\u9653\uf283\u019b\ub361\u665b', |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup121 = device0.createBindGroup({ |
| label: '\u0415\u0b7e\uafc1\u{1f951}\u0b94', |
| layout: bindGroupLayout20, |
| entries: [{binding: 45, resource: sampler5}], |
| }); |
| let commandEncoder223 = device0.createCommandEncoder({}); |
| let texture215 = device0.createTexture({ |
| size: [2, 2, 12], |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture216 = device0.createTexture({ |
| size: [2, 2, 12], |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder59 = commandEncoder223.beginRenderPass({ |
| label: '\u{1ff1e}\u6ad7\u068e', |
| colorAttachments: [{ |
| view: textureView104, |
| clearValue: { r: 864.1, g: -885.8, b: 148.9, a: 691.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture20 = device0.importExternalTexture({source: video3}); |
| try { |
| computePassEncoder155.setBindGroup(0, bindGroup8, []); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer63, 1_560); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(2, buffer71, 300); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| await gc(); |
| let imageData34 = new ImageData(64, 92); |
| let texture217 = device0.createTexture({ |
| size: {width: 600, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture218 = device0.createTexture({ |
| size: [75], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler130 = device0.createSampler({ |
| label: '\u{1fa9c}\u0eec\uf2ff\u{1fac6}\u8f22\u0578\u3d78\ua271\u{1fd06}\u4c5d\uf77b', |
| addressModeW: 'repeat', |
| lodMaxClamp: 96.49, |
| compare: 'always', |
| }); |
| try { |
| renderPassEncoder49.setBindGroup(3, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(0, bindGroup16, new Uint32Array(1994), 671, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle0, renderBundle20, renderBundle9, renderBundle26]); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(152, 275, 1_167_470_686, 391_645_419); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer53, 884); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer119, 4_480); |
| } catch {} |
| let bindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 407, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let buffer139 = device0.createBuffer({ |
| size: 21690, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder224 = device0.createCommandEncoder({}); |
| let textureView186 = texture215.createView({dimension: 'cube'}); |
| let renderPassEncoder60 = commandEncoder224.beginRenderPass({ |
| colorAttachments: [{view: textureView183, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 78580474, |
| }); |
| let sampler131 = device0.createSampler({minFilter: 'nearest', mipmapFilter: 'nearest', lodMinClamp: 10.23, lodMaxClamp: 54.51}); |
| try { |
| renderPassEncoder8.draw(50, 378, 270_312_128, 241_147_291); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer21, 920); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer26, 1_668); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| let sampler132 = device0.createSampler({ |
| label: '\ua2ca\u{1f7a6}', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 15.43, |
| lodMaxClamp: 78.25, |
| }); |
| try { |
| computePassEncoder69.setBindGroup(3, bindGroup64, []); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(1, bindGroup73, new Uint32Array(241), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBlendConstant({ r: 599.3, g: 542.9, b: -418.7, a: 26.79, }); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer52, 568); |
| } catch {} |
| try { |
| buffer60.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let imageData35 = new ImageData(36, 20); |
| let textureView187 = texture196.createView({dimension: '2d-array'}); |
| let sampler133 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 64.27, |
| lodMaxClamp: 96.49, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(1, bindGroup3, new Uint32Array(193), 93, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(27, 162, 1, 325_640_327, 534_505_130); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer134, 'uint32', 5_044, 1_014); |
| } catch {} |
| try { |
| computePassEncoder71.popDebugGroup(); |
| } catch {} |
| let textureView188 = texture215.createView({dimension: 'cube'}); |
| try { |
| computePassEncoder141.setBindGroup(3, bindGroup67); |
| } catch {} |
| try { |
| computePassEncoder73.setBindGroup(3, bindGroup60, new Uint32Array(1311), 88, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(64, 237, 63, 21_125_892, 152_740_264); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 164, height: 12, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData32, |
| origin: { x: 1, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup122 = device0.createBindGroup({ |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 15, resource: {buffer: buffer68, offset: 0, size: 148}}, |
| {binding: 0, resource: textureView6}, |
| ], |
| }); |
| let buffer140 = device0.createBuffer({ |
| size: 15368, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder65.setBindGroup(2, bindGroup68, new Uint32Array(298), 10, 0); |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle27, renderBundle6, renderBundle27]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer135, 396); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(7, buffer133, 0, 1_165); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup123 = device0.createBindGroup({ |
| label: '\u949b\ud2b1\u0c6b\u923a', |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 0, resource: textureView179}, |
| {binding: 15, resource: {buffer: buffer107, offset: 768, size: 536}}, |
| ], |
| }); |
| let querySet34 = device0.createQuerySet({type: 'occlusion', count: 285}); |
| let textureView189 = texture199.createView({}); |
| try { |
| computePassEncoder160.setBindGroup(0, bindGroup79, new Uint32Array(517), 35, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.setBindGroup(1, bindGroup114); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(0, bindGroup51, new Uint32Array(164), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(9, 205, 984_056_123, 365_501_589); |
| } catch {} |
| try { |
| renderPassEncoder56.setIndexBuffer(buffer27, 'uint32', 40, 467); |
| } catch {} |
| let bindGroupLayout29 = device0.createBindGroupLayout({ |
| label: '\ua469\u768c\u{1f8eb}\u823a\u41f2\u041f\uacea\u{1f8ec}', |
| entries: [ |
| { |
| binding: 9, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView190 = texture4.createView({dimension: '2d-array'}); |
| let textureView191 = texture41.createView({label: '\u{1f765}\u0068\u0e69\u1160\ud89d\u{1f753}\u{1fa3c}\u5620\u0a3c\u39b2', mipLevelCount: 1}); |
| try { |
| renderPassEncoder30.setBlendConstant({ r: 475.2, g: -241.8, b: -741.0, a: -208.7, }); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 235, 0, 1_690_877_110); |
| } catch {} |
| let querySet35 = device0.createQuerySet({type: 'occlusion', count: 532}); |
| try { |
| renderPassEncoder8.draw(245, 46, 149_419_039, 525_062); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(1, 180, 3, 294_112_629, 843_484_933); |
| } catch {} |
| try { |
| renderPassEncoder57.setPipeline(pipeline14); |
| } catch {} |
| let bindGroup124 = device0.createBindGroup({layout: bindGroupLayout17, entries: [{binding: 67, resource: textureView109}]}); |
| let pipelineLayout26 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let texture219 = device0.createTexture({ |
| size: [329, 24, 1], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder94.setBindGroup(1, bindGroup63, new Uint32Array(775), 258, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup0, new Uint32Array(2309), 98, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer51, 1_736); |
| } catch {} |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer101, 'uint16', 4_110, 4_447); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer43, 180, new Float32Array(6553)); |
| } catch {} |
| let bindGroup125 = device0.createBindGroup({ |
| layout: bindGroupLayout1, |
| entries: [ |
| {binding: 589, resource: {buffer: buffer78, offset: 2560}}, |
| {binding: 19, resource: textureView43}, |
| {binding: 168, resource: sampler84}, |
| ], |
| }); |
| let sampler134 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.09, |
| }); |
| try { |
| renderPassEncoder5.drawIndexed(3, 3, 0, -1_281_372_453, 2_009_930_378); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer27, 92); |
| } catch {} |
| let texture220 = device0.createTexture({ |
| size: {width: 659, height: 48, depthOrArrayLayers: 86}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder150.setBindGroup(0, bindGroup91); |
| } catch {} |
| try { |
| computePassEncoder103.setBindGroup(1, bindGroup122, new Uint32Array(3269), 21, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(146, 27, 618_375_066, 194_176_574); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(122, 7, 10, -1_704_152_451, 70_846_513); |
| } catch {} |
| try { |
| renderPassEncoder41.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.lost.then(r => { log('device0 lost!'); log(r.message, r.reason); }); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| let commandEncoder225 = device0.createCommandEncoder({}); |
| let computePassEncoder162 = commandEncoder225.beginComputePass({}); |
| let sampler135 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 67.77, |
| lodMaxClamp: 95.07, |
| compare: 'greater-equal', |
| }); |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup111); |
| } catch {} |
| try { |
| renderPassEncoder41.setBindGroup(1, bindGroup11, new Uint32Array(2100), 758, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle22]); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(72, 38, 525_968_141, 804_601_658); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(3, 33, 2, 612_421_247, 475_305_516); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer132, 'uint32', 676, 1_330); |
| } catch {} |
| await gc(); |
| let buffer141 = device0.createBuffer({size: 4105, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer48, 668); }; |
| } catch {} |
| try { |
| computePassEncoder99.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder50.executeBundles([renderBundle22]); |
| } catch {} |
| let bindGroup126 = device0.createBindGroup({layout: bindGroupLayout17, entries: [{binding: 67, resource: textureView123}]}); |
| let texture221 = device0.createTexture({ |
| size: {width: 75, height: 12, depthOrArrayLayers: 77}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup64, new Uint32Array(1212), 3, 0); |
| } catch {} |
| try { |
| computePassEncoder162.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(274, 892, 852_444_722, 592_068_823); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(86, 54, 6, -1_937_195_723, 880_386_236); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer66, 916); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer99, 1_572); |
| } catch {} |
| let bindGroup127 = device0.createBindGroup({ |
| layout: bindGroupLayout16, |
| entries: [{binding: 92, resource: textureView165}, {binding: 73, resource: textureView108}], |
| }); |
| let querySet36 = device0.createQuerySet({label: '\u2737\ud7b4\u6f14\u{1fe07}\u0190\ub686\u8e87\u09e7\u2493', type: 'occlusion', count: 2692}); |
| let texture222 = device0.createTexture({ |
| size: [150, 24, 1], |
| mipLevelCount: 2, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView192 = texture182.createView({dimension: 'cube', baseArrayLayer: 1}); |
| try { |
| computePassEncoder91.setBindGroup(1, bindGroup91, []); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup78, new Uint32Array(528), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(43, 63, 550_448_178, 696_393_958); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(32, 9, 42, -1_950_104_650, 257_911_543); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer129, 7_764); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer68, 'uint32', 820, 207); |
| } catch {} |
| let promise23 = shaderModule10.getCompilationInfo(); |
| let pipelineLayout27 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer142 = device0.createBuffer({ |
| size: 4712, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture223 = device0.createTexture({size: [164, 12, 1], format: 'depth16unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| computePassEncoder58.setBindGroup(0, bindGroup115, new Uint32Array(131), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup60, new Uint32Array(163), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.beginOcclusionQuery(38); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 143, 0, 1_121_607_503); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer105, 1_304); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer111, 'uint16', 16, 13); |
| } catch {} |
| try { |
| buffer74.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let texture224 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 12}, |
| dimension: '2d', |
| format: 'r16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r16sint'], |
| }); |
| let sampler136 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 73.53, |
| compare: 'less', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder74.setBindGroup(2, bindGroup113, new Uint32Array(725), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.setBindGroup(2, bindGroup90, []); |
| } catch {} |
| try { |
| renderPassEncoder53.beginOcclusionQuery(526); |
| } catch {} |
| try { |
| renderPassEncoder54.executeBundles([renderBundle14]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer107, 276); |
| } catch {} |
| try { |
| renderPassEncoder59.setPipeline(pipeline9); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 0, new Float32Array(41720), 13369, 1824); |
| } catch {} |
| let bindGroupLayout30 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 565, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder226 = device0.createCommandEncoder({}); |
| let textureView193 = texture165.createView({}); |
| let texture225 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 12}, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView194 = texture124.createView({format: 'rgba32float', mipLevelCount: 1}); |
| let renderPassEncoder61 = commandEncoder226.beginRenderPass({ |
| label: '\u1228\uc1e3\u0e4c\u{1f877}\uf426\uaf0f\u{1f9b0}\u3567\ueb08\u05c9\u1038', |
| colorAttachments: [{view: textureView132, depthSlice: 179, loadOp: 'clear', storeOp: 'discard'}], |
| depthStencilAttachment: { |
| view: textureView110, |
| depthClearValue: 6.179156427145426, |
| depthLoadOp: 'load', |
| depthStoreOp: 'discard', |
| depthReadOnly: false, |
| stencilClearValue: 11115, |
| }, |
| maxDrawCount: 235957195, |
| }); |
| let sampler137 = device0.createSampler({ |
| label: '\u0326\ub324\ud619\uedee', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 13.20, |
| lodMaxClamp: 34.73, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder48.setBindGroup(3, bindGroup52, new Uint32Array(307), 74, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup11, []); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(0, 9, 8, 18_508_629, 339_907_229); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer68, 132); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let bindGroupLayout31 = pipeline12.getBindGroupLayout(0); |
| let texture226 = device0.createTexture({ |
| size: {width: 720}, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder61.setBindGroup(1, bindGroup80, new Uint32Array(3741), 189, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(5, 51, 3, 384_740_597, 772_500_729); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer78, 48); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 48, depthOrArrayLayers: 3} |
| */ |
| { |
| source: imageData18, |
| origin: { x: 10, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 2, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer22.detached) { new Uint8Array(arrayBuffer22).fill(0x55); }; |
| } catch {} |
| let buffer143 = device0.createBuffer({ |
| size: 20230, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder227 = device0.createCommandEncoder({}); |
| let textureView195 = texture226.createView({label: '\u0cc3\uda85', arrayLayerCount: 1}); |
| let computePassEncoder163 = commandEncoder227.beginComputePass({}); |
| try { |
| computePassEncoder51.setBindGroup(3, bindGroup89); |
| } catch {} |
| try { |
| computePassEncoder102.setPipeline(pipeline13); |
| } catch {} |
| try { |
| computePassEncoder163.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle0, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(25, 21, 257_113_700, 43_907_512); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer19, 248); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture102, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(17).fill(246), /* required buffer size: 17 */ |
| {offset: 17}, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder45.setBindGroup(2, bindGroup31, new Uint32Array(714), 192, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer107, 304); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| let videoFrame31 = new VideoFrame(videoFrame30, {timestamp: 0}); |
| try { |
| renderPassEncoder11.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder14.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(89, 167, 1_227_763_916, 257_220_882); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer66, 2_844); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup128 = device0.createBindGroup({layout: bindGroupLayout30, entries: [{binding: 565, resource: textureView195}]}); |
| let commandEncoder228 = device0.createCommandEncoder({}); |
| let computePassEncoder164 = commandEncoder228.beginComputePass({}); |
| try { |
| computePassEncoder164.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(17, 91, 559_293_544, 788_850_716); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(48, 60, 10, 659_897_105, 1_410_157_662); |
| } catch {} |
| let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'bt1361ExtendedColourGamut'} }); |
| let texture227 = device0.createTexture({ |
| size: [2, 2, 12], |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder3.drawIndexed(73, 29, 16, 253_307_538, 698_728_789); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer38, 196); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer68, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.pushDebugGroup('\u{1f8f2}'); |
| } catch {} |
| try { |
| renderPassEncoder51.popDebugGroup(); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); }; |
| } catch {} |
| let commandEncoder229 = device0.createCommandEncoder({}); |
| let texture228 = device0.createTexture({ |
| size: {width: 659, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup31, new Uint32Array(4), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(5, 498, 1_387_456_494, 279_463_224); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(52, 43, 16, -1_010_776_839, 199_451_386); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer53, 944); |
| } catch {} |
| try { |
| commandEncoder229.copyBufferToBuffer(buffer21, 56, buffer99, 248, 64); |
| } catch {} |
| try { |
| commandEncoder229.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1088 */ |
| offset: 1088, |
| buffer: buffer1, |
| }, { |
| texture: texture184, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let buffer144 = device0.createBuffer({ |
| size: 17836, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let texture229 = device0.createTexture({ |
| size: [360, 1, 1], |
| mipLevelCount: 4, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let sampler138 = device0.createSampler({ |
| label: '\u0b9d\u0c83\u{1fdd0}\u9a1a', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder50.setBindGroup(1, bindGroup48, new Uint32Array(1864), 133, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder56); computePassEncoder56.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexed(99, 839, 175, 305_536_364, 471_567_222); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer68, 168); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(2, buffer144, 0, 2_264); |
| } catch {} |
| try { |
| commandEncoder229.copyTextureToTexture({ |
| texture: texture160, |
| mipLevel: 0, |
| origin: {x: 9, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 96, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 57, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer145 = device0.createBuffer({ |
| label: '\u8f50\u085b\u1908\u0af5\u7ed6\u{1fd09}\u6ba3\u15b5\u9bc4\uf26d\u0933', |
| size: 1525, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder230 = device0.createCommandEncoder({}); |
| let texture230 = device0.createTexture({ |
| size: {width: 75}, |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler139 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 88.63, |
| }); |
| try { |
| renderPassEncoder23.executeBundles([renderBundle2, renderBundle20, renderBundle9, renderBundle2, renderBundle20, renderBundle2, renderBundle9, renderBundle3, renderBundle21, renderBundle21]); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(31, 15, 315_067_544, 1_856_035_131); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline9); |
| } catch {} |
| try { |
| commandEncoder230.copyTextureToTexture({ |
| texture: texture160, |
| mipLevel: 0, |
| origin: {x: 29, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup129 = device0.createBindGroup({ |
| layout: bindGroupLayout31, |
| entries: [ |
| {binding: 234, resource: sampler105}, |
| {binding: 15, resource: textureView20}, |
| {binding: 49, resource: textureView5}, |
| {binding: 374, resource: textureView35}, |
| ], |
| }); |
| let textureView196 = texture21.createView({dimension: '2d-array', format: 'rgb10a2unorm'}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame15, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder103.setBindGroup(0, bindGroup70, new Uint32Array(2128), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer108, 1_060); |
| } catch {} |
| try { |
| renderPassEncoder54.setIndexBuffer(buffer124, 'uint32', 2_484, 3_419); |
| } catch {} |
| document.body.append(img4); |
| let shaderModule18 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| enable f16; |
| /* target size: 8 max align: 8 */ |
| struct T0 { |
| @size(8) f0: atomic<i32>, |
| } |
| /* target size: 73 max align: 1 */ |
| struct T1 { |
| @align(1) @size(73) f0: atomic<i32>, |
| } |
| /* target size: 12 max align: 4 */ |
| struct T2 { |
| @align(1) @size(8) f0: atomic<u32>, |
| f1: array<atomic<u32>, 1>, |
| } |
| @group(0) @binding(67) var st38: texture_storage_2d<rgba8snorm, read>; |
| struct VertexOutput19 { |
| @builtin(position) f64: vec4f |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput19 { |
| var out: VertexOutput19; |
| return out; |
| } |
| struct VertexOutput20 { |
| @location(11) @interpolate(flat, centroid) f65: vec3i, |
| @builtin(position) f66: vec4f, |
| @location(3) @interpolate(perspective, sample) f67: f32, |
| @location(12) @interpolate(flat) f68: vec4h |
| } |
| |
| @vertex |
| fn vertex1() -> VertexOutput20 { |
| var out: VertexOutput20; |
| out.f66 %= vec4f(0.02570, 0.4283, 0.07145, 0.09166); |
| return out; |
| } |
| |
| @compute @workgroup_size(4, 1, 1) |
| fn compute0() { |
| }`, |
| hints: {}, |
| }); |
| let bindGroup130 = device0.createBindGroup({ |
| layout: bindGroupLayout26, |
| entries: [ |
| {binding: 390, resource: {buffer: buffer129, offset: 6656, size: 1252}}, |
| {binding: 55, resource: {buffer: buffer102, offset: 2816}}, |
| ], |
| }); |
| let commandEncoder231 = device0.createCommandEncoder({label: '\u0a02\u027d\u2b40\u2551\u51bc\u0c4a\uf55f'}); |
| let textureView197 = texture143.createView({dimension: '2d-array', format: 'rgba32float', baseArrayLayer: 0}); |
| let sampler140 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 22.04, |
| lodMaxClamp: 23.18, |
| }); |
| try { |
| renderPassEncoder53.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder23.executeBundles([renderBundle9, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(174, 195, 34, 275_278_920, 24_693_580); |
| } catch {} |
| try { |
| renderPassEncoder37.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(2, buffer133, 0, 110); |
| } catch {} |
| try { |
| commandEncoder229.copyBufferToBuffer(buffer53, 160, buffer58, 1928, 556); |
| } catch {} |
| try { |
| commandEncoder230.copyBufferToTexture({ |
| /* bytesInLastRow: 1200 widthInBlocks: 600 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 732 */ |
| offset: 732, |
| buffer: buffer120, |
| }, { |
| texture: texture99, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 600, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder231.copyTextureToTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 8, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame28.close(); |
| videoFrame30.close(); |
| videoFrame31.close(); |
| videoFrame32.close(); |
| 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> |
| |
