| <!-- webkit-test-runner [ enableMetalDebugDevice=true ] --> |
| <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; |
| |
| function gc() { |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUCommandEncoder} commandEncoder |
| */ |
| function pseudoSubmit(device, commandEncoder) { |
| device.pushErrorScope('validation'); |
| commandEncoder.clearBuffer(device.createBuffer({size: 0, usage: 0}), 0, 0); |
| device.popErrorScope().then(() => {}); |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUBuffer} buffer |
| */ |
| function dissociateBuffer(device, buffer) { |
| let commandEncoder = device.createCommandEncoder(); |
| if (buffer.usage & GPUBufferUsage.COPY_DST) { |
| let writeBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| commandEncoder.copyBufferToBuffer(writeBuffer, 0, buffer, 0, 0); |
| } else if (buffer.usage & GPUBufferUsage.COPY_SRC) { |
| let readBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| commandEncoder.copyBufferToBuffer(buffer, 0, readBuffer, 0, 0); |
| } |
| } |
| |
| /** |
| * @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; |
| } |
| |
| /** |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData() { |
| const veryBrightVideo = `data:video/mp4;base64,AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAAhmcmVlAAAAvG1kYXQAAAAfTgEFGkdWStxcTEM/lO/FETzRQ6gD7gAA7gIAA3EYgAAAAEgoAa8iNjAkszOL+e58c//cEe//0TT//scp1n/381P/RWP/zOW4QtxorfVogeh8nQDbQAAAAwAQMCcWUTAAAAMAAAMAAAMA84AAAAAVAgHQAyu+KT35E7gAADFgAAADABLQAAAAEgIB4AiS76MTkNbgAAF3AAAPSAAAABICAeAEn8+hBOTXYAADUgAAHRAAAAPibW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAAKcAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAw10cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAAKcAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAABAAAAAQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAACnAAAAAAABAAAAAAKFbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAABdwAAAD6BVxAAAAAAAMWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABDb3JlIE1lZGlhIFZpZGVvAAAAAixtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAHsc3RibAAAARxzdHNkAAAAAAAAAAEAAAEMaHZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAQABAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAAHVodmNDAQIgAAAAsAAAAAAAPPAA/P36+gAACwOgAAEAGEABDAH//wIgAAADALAAAAMAAAMAPBXAkKEAAQAmQgEBAiAAAAMAsAAAAwAAAwA8oBQgQcCTDLYgV7kWVYC1CRAJAICiAAEACUQBwChkuNBTJAAAAApmaWVsAQAAAAATY29scm5jbHgACQAQAAkAAAAAEHBhc3AAAAABAAAAAQAAABRidHJ0AAAAAAAALPwAACz8AAAAKHN0dHMAAAAAAAAAAwAAAAIAAAPoAAAAAQAAAAEAAAABAAAD6AAAABRzdHNzAAAAAAAAAAEAAAABAAAAEHNkdHAAAAAAIBAQGAAAAChjdHRzAAAAAAAAAAMAAAABAAAAAAAAAAEAAAfQAAAAAgAAAAAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAAQAAAABAAAAJHN0c3oAAAAAAAAAAAAAAAQAAABvAAAAGQAAABYAAAAWAAAAFHN0Y28AAAAAAAAAAQAAACwAAABhdWR0YQAAAFltZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAACxpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYwLjMuMTAw`; |
| let video = document.createElement('video'); |
| video.src = veryBrightVideo; |
| 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({ |
| defaultQueue: {label: '\u48e2\u03ac\ud27b\u0b1c\udae6\u0b88\u312e\ub534\u145b'}, |
| requiredFeatures: [ |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxBindGroups: 7, |
| maxColorAttachmentBytesPerSample: 56, |
| maxVertexAttributes: 24, |
| maxVertexBufferArrayStride: 64488, |
| maxStorageTexturesPerShaderStage: 30, |
| maxStorageBuffersPerShaderStage: 30, |
| maxDynamicStorageBuffersPerPipelineLayout: 51489, |
| maxDynamicUniformBuffersPerPipelineLayout: 13438, |
| maxBindingsPerBindGroup: 6765, |
| maxTextureArrayLayers: 1336, |
| maxTextureDimension1D: 9992, |
| maxTextureDimension2D: 12587, |
| maxVertexBuffers: 11, |
| maxBindGroupsPlusVertexBuffers: 29, |
| maxUniformBufferBindingSize: 203205787, |
| maxUniformBuffersPerShaderStage: 39, |
| maxSampledTexturesPerShaderStage: 18, |
| maxInterStageShaderVariables: 88, |
| maxInterStageShaderComponents: 87, |
| maxSamplersPerShaderStage: 22, |
| }, |
| }); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMinClamp: 29.04, |
| }); |
| let querySet0 = device0.createQuerySet({label: '\uecc0\udd54\u39f9\u14d7\u6b1c\u8c38', type: 'occlusion', count: 660}); |
| let texture0 = device0.createTexture({ |
| label: '\u{1ffbf}\u35e2\u7cbf\u0e01\u{1f7cf}\u0a05', |
| size: {width: 640, height: 80, depthOrArrayLayers: 743}, |
| mipLevelCount: 5, |
| format: 'astc-10x5-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-10x5-unorm', 'astc-10x5-unorm', 'astc-10x5-unorm'], |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({label: '\u3cd5\u093a\u57b3\uafa7\u5d46'}); |
| let textureView0 = texture0.createView({ |
| label: '\ua455\u0858\u0ed7\u157a\u86b1\u7278\u002a', |
| dimension: '2d', |
| mipLevelCount: 3, |
| baseArrayLayer: 492, |
| }); |
| let computePassEncoder0 = commandEncoder0.beginComputePass(); |
| let sampler1 = device0.createSampler({ |
| label: '\u{1fc53}\ud305\u{1fa7f}\u{1fa84}\uefa9', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 97.67, |
| maxAnisotropy: 1, |
| }); |
| let commandEncoder1 = device0.createCommandEncoder({label: '\u0029\ue554\u{1f6fc}\ue795\u66bc\uc6a2\u{1fd50}\u1f4e\u0185\u{1fd8a}\ueb36'}); |
| let querySet1 = device0.createQuerySet({label: '\ub613\u1af8\u261c\u225c\u1e5b\uaa69\u69d2', type: 'occlusion', count: 3465}); |
| let computePassEncoder1 = commandEncoder1.beginComputePass(); |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(955, 783); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let sampler2 = device0.createSampler({ |
| label: '\u{1fafd}\uc833\u0216', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 86.32, |
| lodMaxClamp: 99.40, |
| maxAnisotropy: 5, |
| }); |
| let bindGroupLayout0 = device0.createBindGroupLayout({ |
| label: '\u{1fcab}\u4385\u0e0e\u03ed\u{1f915}\ub3dc\u216e\u0a0b\u03a2\u22a0\u0d8d', |
| entries: [{binding: 1530, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({ |
| label: '\u{1fca7}\ue038\u{1fd2f}\u1b25\u526d', |
| bindGroupLayouts: [bindGroupLayout0, bindGroupLayout0, bindGroupLayout0, bindGroupLayout0], |
| }); |
| let buffer0 = device0.createBuffer({size: 513978, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder3 = device0.createCommandEncoder({label: '\u{1f9df}\u1037\ubdee'}); |
| let texture1 = device0.createTexture({ |
| size: {width: 640}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32sint'], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({ |
| label: '\u2dfd\u0654\u{1f728}\u82d1\u058d\u{1ffd3}\u2c3e\u0927', |
| bindGroupLayouts: [bindGroupLayout0, bindGroupLayout0, bindGroupLayout0], |
| }); |
| let commandEncoder4 = device0.createCommandEncoder({label: '\u44e2\u83fb\u0d95\uaa6e\u66d9\ua27e\u0567'}); |
| let texture2 = device0.createTexture({ |
| size: {width: 150, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({ |
| label: '\u{1fbd9}\u{1f74d}\u51f1\u{1fc74}\u0569\u95c5\u0d65\u0e57\uc087', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| }); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu'); |
| try { |
| adapter0.label = '\ud1f7\u{1f856}\ua6e5\u{1f9c3}\ufdac\u09ed'; |
| } catch {} |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let sampler3 = device0.createSampler({ |
| label: '\u{1fe85}\ucd27\uf786\u{1fb01}\u0592', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 15.84, |
| maxAnisotropy: 15, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer0, 180284, new BigUint64Array(41212), 35895, 600); |
| } catch {} |
| let textureView1 = texture2.createView({dimension: '2d-array', format: 'rg8uint', baseMipLevel: 2}); |
| let renderBundle0 = renderBundleEncoder0.finish(); |
| let sampler4 = device0.createSampler({ |
| label: '\ucb2f\u0737\u{1f8a5}\u0771\u5db9\u52ed', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 47.15, |
| lodMaxClamp: 85.29, |
| }); |
| try { |
| commandEncoder3.clearBuffer(buffer0, 442012, 20260); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(116, 737); |
| let video0 = await videoWithData(); |
| let shaderModule0 = device0.createShaderModule({ |
| label: '\u9bfa\ufd86\u0749\uf698\u061a\u{1fc50}\u77ca', |
| code: `@group(2) @binding(1530) |
| var<storage, read_write> function0: array<u32>; |
| @group(3) @binding(1530) |
| var<storage, read_write> function1: array<u32>; |
| @group(0) @binding(1530) |
| var<storage, read_write> type0: array<u32>; |
| |
| @compute @workgroup_size(7, 3, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(0) f0: vec3<u32>, |
| @location(4) f1: vec4<f32>, |
| @location(2) f2: vec4<u32>, |
| @location(3) f3: vec4<i32>, |
| @location(1) f4: vec2<i32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32, @builtin(position) a1: vec4<f32>, @builtin(sample_mask) a2: u32, @builtin(front_facing) a3: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(19) a0: vec2<u32>, @location(14) a1: u32, @location(21) a2: f32, @location(16) a3: u32, @location(11) a4: vec4<f16>, @location(18) a5: vec4<f16>, @location(13) a6: vec3<f16>, @location(5) a7: vec4<f32>, @location(4) a8: vec2<u32>, @location(23) a9: f32, @location(1) a10: vec3<f32>, @location(3) a11: vec2<f32>, @location(12) a12: f32, @location(9) a13: vec4<f32>, @location(8) a14: vec3<u32>, @location(2) a15: u32, @location(10) a16: vec3<u32>, @location(15) a17: vec2<u32>, @location(20) a18: f32, @location(0) a19: vec3<f32>, @builtin(instance_index) a20: u32, @location(22) a21: vec4<f16>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer1 = device0.createBuffer({ |
| label: '\uc201\u{1f894}\u0a8d\u{1f7d9}\u1263\u0036\u729f\u12ca\u0d41\ud1f9', |
| size: 363354, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT, |
| }); |
| let renderBundle1 = renderBundleEncoder0.finish({}); |
| let imageData0 = new ImageData(220, 8); |
| try { |
| offscreenCanvas1.getContext('webgpu'); |
| } catch {} |
| let textureView2 = texture1.createView({label: '\uba18\u{1f6b7}\u0026\u0cd4'}); |
| let pipeline0 = await device0.createRenderPipelineAsync({ |
| label: '\u509d\u{1fdc6}\u4b84\u0fa6\u1c19\u{1f7bf}\u7e32', |
| layout: pipelineLayout0, |
| multisample: {mask: 0x164e3ba1}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.BLUE}, {format: 'r16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'r32sint'}, {format: 'rgba8unorm-srgb'}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 2968, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x2', offset: 568, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 320, shaderLocation: 9}, |
| {format: 'uint32x3', offset: 1276, shaderLocation: 19}, |
| {format: 'uint8x4', offset: 16, shaderLocation: 2}, |
| {format: 'uint16x2', offset: 1236, shaderLocation: 16}, |
| {format: 'uint32x4', offset: 36, shaderLocation: 8}, |
| {format: 'unorm8x2', offset: 238, shaderLocation: 12}, |
| {format: 'float16x2', offset: 432, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 368, shaderLocation: 5}, |
| {format: 'uint32', offset: 136, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 300, shaderLocation: 22}, |
| {format: 'unorm8x2', offset: 912, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 120, shaderLocation: 0}, |
| {format: 'snorm8x4', offset: 448, shaderLocation: 20}, |
| {format: 'uint16x4', offset: 1148, shaderLocation: 15}, |
| ], |
| }, |
| { |
| arrayStride: 2792, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 80, shaderLocation: 14}, |
| {format: 'float16x2', offset: 308, shaderLocation: 18}, |
| {format: 'unorm8x4', offset: 428, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 594, shaderLocation: 23}, |
| {format: 'float16x4', offset: 836, shaderLocation: 21}, |
| {format: 'float32x3', offset: 508, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let commandBuffer0 = commandEncoder2.finish(); |
| let textureView3 = texture0.createView({baseMipLevel: 2, baseArrayLayer: 723, arrayLayerCount: 13}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({ |
| label: '\u0e96\u1a3c\u0e64\u1b89\ubcad\u0c9b\u{1f6e7}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| }); |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| try { |
| adapter0.label = '\u{1fcd6}\u89a0\u{1fd29}\u0750\u5e45\ua11f\u{1f9a0}\u516c\u0255\u713e\u0243'; |
| } catch {} |
| let commandBuffer1 = commandEncoder5.finish({label: '\u60e2\u{1fe14}\u{1fdbd}\u090a\u5aea\u{1fd6b}\uaf3c'}); |
| let textureView4 = texture1.createView({label: '\u2098\u14c7\u6b07\u904c\u8777\u{1f968}\u9218\uc098', aspect: 'all'}); |
| let renderBundle2 = renderBundleEncoder1.finish(); |
| let sampler5 = device0.createSampler({ |
| label: '\uac61\ucf8e\u4d23\u4152', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 80.70, |
| lodMaxClamp: 86.70, |
| maxAnisotropy: 15, |
| }); |
| try { |
| await device0.popErrorScope(); |
| } catch {} |
| try { |
| computePassEncoder1.insertDebugMarker('\u03f8'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let pipeline1 = await device0.createComputePipelineAsync({ |
| label: '\uab57\u5e25\u0529\u82ac\u07f6\u2c0f', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule0, entryPoint: 'compute0'}, |
| }); |
| try { |
| await promise0; |
| } catch {} |
| gc(); |
| let commandBuffer2 = commandEncoder3.finish({label: '\ubeee\u5c41\udc6f\u57d4\u0182\u333a'}); |
| let texture3 = device0.createTexture({ |
| label: '\ued83\u8c24', |
| size: [1200, 192, 1], |
| mipLevelCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView5 = texture3.createView({ |
| label: '\u04b7\u{1fc93}\udea5\ub41f\u{1f691}\u5ff4\u57a1\u823e', |
| dimension: '2d-array', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| }); |
| let computePassEncoder2 = commandEncoder4.beginComputePass({label: '\u0fb8\u{1ff18}\u{1f9c1}\u9acf'}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({ |
| label: '\u5bf3\u0aba\u01d4\u0a99\u02e1', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let texture4 = device0.createTexture({ |
| label: '\u37d7\u0831\u2b0c\u177b\uefaf', |
| size: [22], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint'], |
| }); |
| let textureView6 = texture3.createView({label: '\u07db\u73c7\u{1f94d}\u74c8\ub1d9\ue2af\u0c01\u426b', mipLevelCount: 1}); |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| commandEncoder1.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 44 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 506 */ |
| offset: 462, |
| bytesPerRow: 256, |
| buffer: buffer0, |
| }, {width: 22, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder1.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 2, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 12, height: 2, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 2, |
| origin: {x: 5, y: 6, z: 0}, |
| aspect: 'all', |
| }, new Uint8ClampedArray(new ArrayBuffer(8)), /* required buffer size: 874 */ |
| {offset: 874, bytesPerRow: 672}, {width: 284, height: 35, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder6 = device0.createCommandEncoder({label: '\u{1fcef}\u8b24\u3f98\uec0e\uba9c\u8356\uf724'}); |
| let textureView7 = texture4.createView({aspect: 'all'}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({ |
| label: '\ucf96\u1803\u{1fabe}\u91e9\u{1fec2}\ubedc\u0459', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| }); |
| try { |
| renderBundleEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 4540, new BigUint64Array(8981), 4546, 1324); |
| } catch {} |
| let sampler6 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 46.28, |
| lodMaxClamp: 62.33, |
| maxAnisotropy: 9, |
| }); |
| let pipeline2 = await device0.createRenderPipelineAsync({ |
| label: '\u0309\u06a4\u{1fb5b}\uadf9\u{1fddc}', |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }, { |
| format: 'rg16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-src-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilFront: {compare: 'greater-equal', failOp: 'decrement-clamp', passOp: 'increment-wrap'}, |
| stencilBack: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'replace', passOp: 'decrement-clamp'}, |
| stencilReadMask: 4294967295, |
| stencilWriteMask: 2946481896, |
| depthBias: 0, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 32576, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x4', offset: 3700, shaderLocation: 16}, |
| {format: 'float32x2', offset: 10136, shaderLocation: 23}, |
| {format: 'uint16x4', offset: 5656, shaderLocation: 14}, |
| {format: 'float32x3', offset: 4692, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 5796, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 9056, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x3', offset: 4116, shaderLocation: 15}, |
| {format: 'snorm16x2', offset: 456, shaderLocation: 13}, |
| {format: 'snorm8x4', offset: 3540, shaderLocation: 11}, |
| {format: 'unorm16x4', offset: 524, shaderLocation: 3}, |
| {format: 'unorm16x4', offset: 608, shaderLocation: 0}, |
| {format: 'unorm8x2', offset: 402, shaderLocation: 22}, |
| {format: 'float16x4', offset: 668, shaderLocation: 9}, |
| {format: 'float32x2', offset: 648, shaderLocation: 20}, |
| {format: 'uint32x2', offset: 472, shaderLocation: 2}, |
| ], |
| }, |
| {arrayStride: 0, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 12052, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'float16x4', offset: 3716, shaderLocation: 21}, |
| {format: 'uint32x2', offset: 1808, shaderLocation: 8}, |
| {format: 'snorm8x4', offset: 392, shaderLocation: 1}, |
| ], |
| }, |
| {arrayStride: 25356, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 5896, |
| attributes: [ |
| {format: 'snorm8x4', offset: 2080, shaderLocation: 12}, |
| {format: 'float32x4', offset: 1056, shaderLocation: 18}, |
| {format: 'uint8x2', offset: 222, shaderLocation: 4}, |
| ], |
| }, |
| {arrayStride: 6460, attributes: [{format: 'uint32x3', offset: 1476, shaderLocation: 19}]}, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'ccw'}, |
| }); |
| offscreenCanvas1.width = 756; |
| let offscreenCanvas2 = new OffscreenCanvas(639, 659); |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let querySet2 = device0.createQuerySet({ |
| label: '\u0b3e\u0e33\u8d60\uec6a\u81ea\u{1ff6a}\u0b23\u{1f606}\u{1f8a1}\u{1fae2}\u7aab', |
| type: 'occlusion', |
| count: 1546, |
| }); |
| let texture5 = device0.createTexture({ |
| size: [600], |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16uint', 'r16uint'], |
| }); |
| let texture6 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundle3 = renderBundleEncoder1.finish(); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder6.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 56 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 45660 */ |
| offset: 45660, |
| bytesPerRow: 256, |
| rowsPerImage: 157, |
| buffer: buffer0, |
| }, {width: 28, height: 6, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let pipeline3 = device0.createComputePipeline({ |
| label: '\ue6ba\u07c9\u00e6\ude77\u{1f821}\u{1f8b4}\u08f5\u04f0', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| gc(); |
| let commandEncoder7 = device0.createCommandEncoder(); |
| let texture7 = device0.createTexture({ |
| label: '\u{1f98c}\u9554\u15ca\u0776\u6507\ud978', |
| size: [300, 48, 1], |
| mipLevelCount: 3, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm'], |
| }); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({ |
| label: '\u{1fd65}\u4dec\u{1fff0}\u0e27\u21f1\u{1f7f1}\u{1f621}\u0c61\u{1f904}\ueda6\u{1f7a8}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| sampleCount: 1, |
| depthReadOnly: true, |
| }); |
| let sampler7 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 39.23, |
| lodMaxClamp: 46.01, |
| }); |
| try { |
| commandEncoder7.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 3, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 2, |
| origin: {x: 1, y: 6, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(new ArrayBuffer(0)), /* required buffer size: 6232 */ |
| {offset: 53, bytesPerRow: 349, rowsPerImage: 77}, {width: 123, height: 18, depthOrArrayLayers: 1}); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(884, 639); |
| let commandEncoder8 = device0.createCommandEncoder({label: '\uebea\ud4b1\u0bea\u0a99'}); |
| let sampler8 = device0.createSampler({ |
| label: '\u{1fd5e}\u0b32', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 50.60, |
| lodMaxClamp: 57.65, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 101, y: 459 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| window.someLabel = commandEncoder5.label; |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 115, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 400 widthInBlocks: 100 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 13472 */ |
| offset: 13472, |
| buffer: buffer1, |
| }, {width: 100, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder({label: '\u{1f816}\u0965'}); |
| let textureView8 = texture0.createView({ |
| label: '\u0d2e\u0b5a\u{1ff7a}\ub8fc\u4b31\ubcd9\u{1f8db}\uc7f0\u2149', |
| dimension: '2d', |
| baseMipLevel: 0, |
| mipLevelCount: 1, |
| baseArrayLayer: 398, |
| }); |
| let renderBundle4 = renderBundleEncoder1.finish({label: '\u321c\u19af\u{1faa0}\u0d76\u0bc3\u03d3\u039d'}); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder7.pushDebugGroup('\u898a'); |
| } catch {} |
| let promise1 = device0.createComputePipelineAsync({ |
| label: '\u9a2e\u0b2a\u12e2\u6fa9\u8b14\u{1f950}\u{1fc17}\u0743\u9557', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let textureView9 = texture7.createView({label: '\u084a\u{1f96f}\u9cd2\u{1fb48}\u{1fb0b}\u9ddc', format: 'rgba8unorm', baseMipLevel: 2}); |
| let externalTexture0 = device0.importExternalTexture({label: '\u929d\ub997\u{1f818}\u{1fdb2}', source: video0, colorSpace: 'srgb'}); |
| try { |
| commandEncoder8.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 31, y: 12, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 47, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder7.clearBuffer(buffer1, 25208, 15592); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 42, y: 131 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer2 = device0.createBuffer({label: '\u{1f7e4}\u0f45', size: 658554, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let externalTexture1 = device0.importExternalTexture({source: video0, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToBuffer({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 48, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 224 widthInBlocks: 56 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 46868 */ |
| offset: 42036, |
| bytesPerRow: 256, |
| buffer: buffer0, |
| }, {width: 56, height: 19, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder9.clearBuffer(buffer0, 455816, 56252); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder7.popDebugGroup(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let computePassEncoder3 = commandEncoder6.beginComputePass(); |
| try { |
| await buffer2.mapAsync(GPUMapMode.WRITE, 0, 103860); |
| } catch {} |
| let pipeline4 = device0.createComputePipeline({ |
| label: '\u1af6\ufbb8\u0e76\u0017\u66b9\uc625\u7e21\u51f4\u0bd5', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let commandEncoder10 = device0.createCommandEncoder({label: '\u18d2\u0d89\u64da\u{1fc1c}'}); |
| let commandBuffer3 = commandEncoder8.finish({label: '\u{1f886}\u{1f89a}\u{1ff90}\u{1fb04}\u{1f95c}\u{1fc9a}\u598b\uc055\u904d'}); |
| let texture8 = device0.createTexture({ |
| size: [176, 96, 196], |
| dimension: '3d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16uint'], |
| }); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer2, 171632, buffer0, 20460, 113932); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 106320, new DataView(new ArrayBuffer(36656)), 19345, 5404); |
| } catch {} |
| let bindGroupLayout1 = device0.createBindGroupLayout({ |
| label: '\u2718\u1ddb\u{1f8f3}\u{1f735}\u{1ffc5}', |
| entries: [{binding: 1494, visibility: 0, sampler: { type: 'filtering' }}], |
| }); |
| let texture9 = device0.createTexture({ |
| label: '\u0b7d\u3e23\u04ec\u{1fa25}', |
| size: [1280], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let pipeline5 = device0.createComputePipeline({ |
| label: '\u4bf4\ucea4\u{1f753}\u9da0\u68b7\ufc53', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let bindGroup0 = device0.createBindGroup({label: '\uf3f3\ub35e', layout: bindGroupLayout1, entries: [{binding: 1494, resource: sampler2}]}); |
| let computePassEncoder4 = commandEncoder9.beginComputePass({label: '\u{1f96f}\ud6ca\u{1f6a1}'}); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({ |
| label: '\ucad2\u08e6\ubd82\ub45c\u{1f6f5}\u6572\u2cb1\u0401\u0f16', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder10.clearBuffer(buffer1, 233512, 112780); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| computePassEncoder3.insertDebugMarker('\u1204'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 27, y: 15 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline6 = device0.createComputePipeline({ |
| label: '\u09ee\udaca\ub796', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let bindGroup1 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 1494, resource: sampler1}]}); |
| let commandBuffer4 = commandEncoder1.finish({label: '\u9c8e\u979d\u2149\u{1f7b8}\u{1facf}\u05a6'}); |
| let textureView10 = texture4.createView({label: '\u351b\u7f57\u02b9\u5c85\u963c\u2363\u69b9\ud2a0\u0a45', baseMipLevel: 0, mipLevelCount: 1}); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], depthReadOnly: true}); |
| let promise2 = buffer0.mapAsync(GPUMapMode.READ, 0, 192256); |
| try { |
| device0.queue.writeBuffer(buffer1, 27664, new BigUint64Array(2586), 1223, 332); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({ |
| label: '\u{1fc5e}\u{1f929}\ub504\ud1cc\uc85a\u24f6\u0cb6\uaae8\u0a49\uc60f', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline8 = device0.createRenderPipeline({ |
| label: '\u875b\ua4c3\u{1f8d2}\ud1e7\u0011\u4a49\u603a\u1898', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg16sint', writeMask: 0}, {format: 'r16uint', writeMask: GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 3712, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 848, shaderLocation: 15}, |
| {format: 'uint8x4', offset: 1440, shaderLocation: 2}, |
| {format: 'unorm16x2', offset: 216, shaderLocation: 22}, |
| {format: 'snorm8x2', offset: 172, shaderLocation: 20}, |
| {format: 'uint32x4', offset: 372, shaderLocation: 16}, |
| {format: 'float32x2', offset: 492, shaderLocation: 21}, |
| ], |
| }, |
| { |
| arrayStride: 18548, |
| attributes: [ |
| {format: 'float32x3', offset: 2712, shaderLocation: 0}, |
| {format: 'uint32', offset: 5988, shaderLocation: 10}, |
| {format: 'uint16x4', offset: 4048, shaderLocation: 8}, |
| {format: 'unorm8x4', offset: 4092, shaderLocation: 11}, |
| {format: 'float32x3', offset: 11928, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 104, shaderLocation: 4}, |
| {format: 'float32x3', offset: 1832, shaderLocation: 23}, |
| {format: 'float32x2', offset: 5868, shaderLocation: 18}, |
| {format: 'unorm16x4', offset: 404, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 3136, shaderLocation: 5}, |
| {format: 'snorm8x4', offset: 28, shaderLocation: 13}, |
| {format: 'uint32x2', offset: 540, shaderLocation: 19}, |
| {format: 'unorm16x2', offset: 4400, shaderLocation: 9}, |
| {format: 'unorm10-10-10-2', offset: 2732, shaderLocation: 1}, |
| {format: 'uint8x2', offset: 784, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let canvas0 = document.createElement('canvas'); |
| try { |
| window.someLabel = device0.label; |
| } catch {} |
| let bindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2593, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 6303, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer3 = device0.createBuffer({size: 46261, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let textureView11 = texture7.createView({format: 'rgba8unorm', baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler9 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 78.04, |
| lodMaxClamp: 92.36, |
| maxAnisotropy: 15, |
| }); |
| try { |
| renderBundleEncoder6.setBindGroup(4, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder10.copyTextureToBuffer({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 10404 */ |
| offset: 10404, |
| rowsPerImage: 297, |
| buffer: buffer1, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder7.clearBuffer(buffer1, 132316, 223072); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| let pipeline9 = device0.createRenderPipeline({ |
| label: '\u0931\u56eb\u9549\u0b15', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, { |
| format: 'rg16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }, { |
| format: 'r16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'r32sint'}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'src', dstFactor: 'one-minus-constant'}, |
| }, |
| writeMask: GPUColorWrite.ALL, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: {compare: 'equal', failOp: 'increment-clamp', depthFailOp: 'replace', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'equal', failOp: 'invert', depthFailOp: 'keep', passOp: 'increment-clamp'}, |
| stencilReadMask: 3504114541, |
| stencilWriteMask: 598939705, |
| depthBias: -1290126271, |
| depthBiasSlopeScale: 0.0, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 13688, |
| attributes: [ |
| {format: 'snorm8x4', offset: 316, shaderLocation: 12}, |
| {format: 'float32x3', offset: 520, shaderLocation: 23}, |
| {format: 'float16x4', offset: 324, shaderLocation: 9}, |
| {format: 'uint32x3', offset: 308, shaderLocation: 2}, |
| {format: 'uint32x3', offset: 2032, shaderLocation: 15}, |
| {format: 'float32x3', offset: 348, shaderLocation: 22}, |
| {format: 'uint8x2', offset: 3034, shaderLocation: 19}, |
| {format: 'uint8x2', offset: 13686, shaderLocation: 14}, |
| {format: 'float32', offset: 832, shaderLocation: 0}, |
| {format: 'float32', offset: 852, shaderLocation: 1}, |
| {format: 'snorm16x4', offset: 2968, shaderLocation: 21}, |
| {format: 'snorm16x4', offset: 1304, shaderLocation: 5}, |
| {format: 'unorm8x2', offset: 5318, shaderLocation: 18}, |
| {format: 'uint16x4', offset: 2672, shaderLocation: 10}, |
| {format: 'uint32', offset: 2120, shaderLocation: 8}, |
| {format: 'float32x2', offset: 3556, shaderLocation: 20}, |
| ], |
| }, |
| { |
| arrayStride: 14816, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32x4', offset: 8752, shaderLocation: 16}, |
| {format: 'snorm16x2', offset: 488, shaderLocation: 13}, |
| {format: 'unorm16x2', offset: 260, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 3304, shaderLocation: 3}, |
| ], |
| }, |
| {arrayStride: 8136, attributes: [{format: 'uint32x2', offset: 416, shaderLocation: 4}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let video1 = await videoWithData(); |
| try { |
| adapter0.label = '\u2b9d\u042f\u{1fcc3}'; |
| } catch {} |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let texture10 = device0.createTexture({ |
| label: '\u289d\u167f', |
| size: {width: 160, height: 20, depthOrArrayLayers: 4}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg8uint'], |
| }); |
| let texture11 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView12 = texture11.createView({label: '\u8e2b\u0b0e\u{1f628}\u0c18\u{1fc8b}\u106c', dimension: '2d-array'}); |
| let computePassEncoder5 = commandEncoder11.beginComputePass({}); |
| let renderBundle5 = renderBundleEncoder6.finish({}); |
| try { |
| renderBundleEncoder4.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToBuffer(buffer3, 11592, buffer1, 125776, 29336); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder10.copyTextureToBuffer({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 580 widthInBlocks: 145 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 11232 */ |
| offset: 9884, |
| bytesPerRow: 768, |
| buffer: buffer1, |
| }, {width: 145, height: 2, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 15, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 54, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 20, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let pipeline10 = await promise1; |
| let texture12 = device0.createTexture({ |
| label: '\u23ac\u61b3\u7ad2\u9880\u8568', |
| size: [1280, 160, 38], |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({ |
| label: '\u9c8e\u{1f6c0}\uf65a', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| }); |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext1 = offscreenCanvas2.getContext('webgpu'); |
| let buffer4 = device0.createBuffer({size: 269974, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandBuffer5 = commandEncoder10.finish({}); |
| let texture13 = device0.createTexture({ |
| label: '\ubaa1\u{1fd09}\u7bcd\u845b\u{1ffab}\u{1f805}\u0c57\uccc8\u1720\ucf19\u0caf', |
| size: [160, 20, 79], |
| mipLevelCount: 7, |
| format: 'astc-5x4-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['astc-5x4-unorm'], |
| }); |
| let renderBundle6 = renderBundleEncoder6.finish(); |
| try { |
| renderBundleEncoder4.setPipeline(pipeline0); |
| } catch {} |
| let promise5 = buffer4.mapAsync(GPUMapMode.WRITE, 0, 9896); |
| try { |
| commandEncoder7.copyBufferToBuffer(buffer3, 42328, buffer1, 188816, 1784); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 34 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 33438 */ |
| offset: 33438, |
| bytesPerRow: 256, |
| buffer: buffer3, |
| }, { |
| texture: texture2, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 17, height: 3, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 4, |
| origin: {x: 5, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 76 widthInBlocks: 38 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5402 */ |
| offset: 5402, |
| bytesPerRow: 256, |
| buffer: buffer1, |
| }, {width: 38, height: 2, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| offscreenCanvas3.getContext('webgl2'); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 1530, resource: externalTexture0}]}); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({ |
| label: '\u0b6c\ufcae\ue0a1\u6cf3\ue17d\u{1f7d7}\ue4e5\u4073\u0019\u{1f82d}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(8, buffer3, 17584); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToBuffer({ |
| texture: texture13, |
| mipLevel: 4, |
| origin: {x: 5, y: 0, z: 2}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 33056 */ |
| offset: 29216, |
| bytesPerRow: 256, |
| rowsPerImage: 1, |
| buffer: buffer1, |
| }, {width: 0, height: 0, depthOrArrayLayers: 16}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder7.clearBuffer(buffer0, 372832, 47092); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| let commandEncoder12 = device0.createCommandEncoder(); |
| let querySet3 = device0.createQuerySet({ |
| label: '\u9750\ub107\u595f\u65fe\u{1fcf5}\u8ae8\uede9\u9477\u0e07\u0f1f\u9056', |
| type: 'occlusion', |
| count: 2486, |
| }); |
| let commandBuffer6 = commandEncoder7.finish({label: '\ub5ec\u{1f65a}\u0ecd\u6072\ubd73\uceed\u00de\u{1f792}\ud004\u0cf5\u618a'}); |
| let textureView13 = texture8.createView({label: '\udfae\ucb00\u79b0\u0cc3'}); |
| let externalTexture2 = device0.importExternalTexture({label: '\u35e5\ufc0c\u028d\ub05b', source: video1, colorSpace: 'srgb'}); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| let pipeline11 = await device0.createComputePipelineAsync({ |
| label: '\u185e\u{1fb7c}\u0dca\ue95b\uc88b', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline12 = device0.createRenderPipeline({ |
| label: '\u791e\uad5c\u1948\uc354\uc0a1\ufb75\u0079\u25b1\u0148', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0xc7805196}, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 4076, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 1040, shaderLocation: 22}, |
| {format: 'float32', offset: 1536, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 420, shaderLocation: 15}, |
| {format: 'float16x2', offset: 936, shaderLocation: 20}, |
| {format: 'float32x4', offset: 1980, shaderLocation: 18}, |
| {format: 'unorm8x4', offset: 1456, shaderLocation: 3}, |
| {format: 'float32x4', offset: 304, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 892, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 12372, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x4', offset: 4064, shaderLocation: 21}, |
| {format: 'float32x2', offset: 1084, shaderLocation: 13}, |
| {format: 'float16x2', offset: 3672, shaderLocation: 5}, |
| {format: 'uint32', offset: 5024, shaderLocation: 2}, |
| {format: 'uint32x3', offset: 12, shaderLocation: 16}, |
| {format: 'uint16x2', offset: 704, shaderLocation: 4}, |
| ], |
| }, |
| { |
| arrayStride: 3584, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 392, shaderLocation: 11}, |
| {format: 'uint32x2', offset: 988, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 72, shaderLocation: 23}, |
| {format: 'uint32', offset: 724, shaderLocation: 19}, |
| {format: 'uint16x4', offset: 20, shaderLocation: 14}, |
| {format: 'float16x2', offset: 1068, shaderLocation: 9}, |
| {format: 'snorm16x4', offset: 396, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| video0.height = 218; |
| let pipelineLayout2 = device0.createPipelineLayout({ |
| label: '\u9254\u{1f6a7}\u{1ff34}\uc6b5', |
| bindGroupLayouts: [bindGroupLayout0, bindGroupLayout1, bindGroupLayout1], |
| }); |
| let commandEncoder13 = device0.createCommandEncoder({label: '\u015d\u0346\u0324\u620b\u3bc5\u{1fd33}\u99ed'}); |
| try { |
| renderBundleEncoder7.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 236 widthInBlocks: 59 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 33648 */ |
| offset: 25732, |
| bytesPerRow: 512, |
| buffer: buffer1, |
| }, {width: 59, height: 16, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let offscreenCanvas4 = new OffscreenCanvas(967, 64); |
| let commandEncoder14 = device0.createCommandEncoder({label: '\u1029\u{1f793}'}); |
| let textureView14 = texture3.createView({dimension: '2d-array', baseMipLevel: 2, baseArrayLayer: 0}); |
| let renderBundle7 = renderBundleEncoder4.finish(); |
| try { |
| computePassEncoder5.setBindGroup(6, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(4, bindGroup2, new Uint32Array(1509), 308, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(2, buffer3, 0, 37554); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToBuffer(buffer3, 8000, buffer1, 97736, 5208); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder13.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 145, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 440 widthInBlocks: 110 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 16268 */ |
| offset: 16268, |
| buffer: buffer1, |
| }, {width: 110, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder14.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 39, y: 6, z: 114}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 18, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder14.clearBuffer(buffer0, 84012, 146168); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 3, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(48), /* required buffer size: 794 */ |
| {offset: 794, bytesPerRow: 535}, {width: 130, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView15 = texture13.createView({ |
| label: '\u0c5e\uf1aa\u{1f752}\u2d29\ubb3d\u{1ff95}\ueb8b\u462d\u0f5c\u0cd8', |
| dimension: '2d', |
| aspect: 'all', |
| baseMipLevel: 4, |
| mipLevelCount: 1, |
| baseArrayLayer: 43, |
| }); |
| try { |
| commandEncoder13.copyBufferToTexture({ |
| /* bytesInLastRow: 164 widthInBlocks: 41 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4236 */ |
| offset: 4236, |
| bytesPerRow: 512, |
| rowsPerImage: 101, |
| buffer: buffer3, |
| }, { |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 6, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 41, height: 9, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder13.clearBuffer(buffer0, 304384, 196752); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let commandBuffer7 = commandEncoder12.finish(); |
| let textureView16 = texture7.createView({ |
| label: '\ud02b\u07b2\u0ed6', |
| dimension: '2d-array', |
| aspect: 'all', |
| format: 'rgba8unorm', |
| baseMipLevel: 2, |
| }); |
| let computePassEncoder6 = commandEncoder14.beginComputePass({label: '\u0ef0\ufe71\u32ac\u543b\u7570\u5be6\u{1f954}'}); |
| let renderBundle8 = renderBundleEncoder7.finish({}); |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 10208, new DataView(new ArrayBuffer(57267)), 51665, 592); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 3, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(0), /* required buffer size: 1045 */ |
| {offset: 571, bytesPerRow: 234}, {width: 3, height: 3, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline13 = device0.createComputePipeline({ |
| label: '\ucb4f\ub311\u0e3d\u0941\u6a7b\ue2bf\ua387', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let bindGroupLayout3 = device0.createBindGroupLayout({ |
| label: '\u0c30\u41f8\u3396\u0ae3\u3e2b\u01f3\u03cc', |
| entries: [{binding: 6255, visibility: 0, sampler: { type: 'non-filtering' }}], |
| }); |
| let bindGroup3 = device0.createBindGroup({ |
| label: '\uf03f\u{1fb9b}\u0e85\udd0d', |
| layout: bindGroupLayout3, |
| entries: [{binding: 6255, resource: sampler4}], |
| }); |
| let commandEncoder15 = device0.createCommandEncoder({label: '\u365a\u0d58'}); |
| let querySet4 = device0.createQuerySet({ |
| label: '\u{1fbe6}\ud9c3\u0c81\u005c\u4425\u020b\u{1f732}\u965f\u3c53\u{1fa0b}\u20cc', |
| type: 'occlusion', |
| count: 3636, |
| }); |
| let commandBuffer8 = commandEncoder15.finish(); |
| let sampler10 = device0.createSampler({ |
| label: '\u{1f9ae}\u30a0', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.08, |
| compare: 'never', |
| maxAnisotropy: 10, |
| }); |
| let pipeline14 = device0.createRenderPipeline({ |
| label: '\u081c\u{1f8c1}', |
| layout: pipelineLayout1, |
| multisample: {mask: 0x1e47e090}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'src'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'zero'}, |
| }, |
| writeMask: GPUColorWrite.BLUE, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| {arrayStride: 5928, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 18144, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32', offset: 1016, shaderLocation: 9}, |
| {format: 'uint8x4', offset: 4756, shaderLocation: 10}, |
| {format: 'uint16x4', offset: 9400, shaderLocation: 16}, |
| {format: 'float32x2', offset: 6052, shaderLocation: 13}, |
| {format: 'float32x2', offset: 3964, shaderLocation: 12}, |
| {format: 'uint8x4', offset: 15588, shaderLocation: 14}, |
| {format: 'unorm16x4', offset: 2572, shaderLocation: 22}, |
| {format: 'uint16x2', offset: 7872, shaderLocation: 15}, |
| {format: 'uint16x2', offset: 1000, shaderLocation: 8}, |
| {format: 'float32x2', offset: 4072, shaderLocation: 3}, |
| {format: 'uint32x4', offset: 4936, shaderLocation: 2}, |
| {format: 'float32x3', offset: 5272, shaderLocation: 5}, |
| {format: 'uint32x2', offset: 4468, shaderLocation: 4}, |
| {format: 'float32', offset: 1832, shaderLocation: 1}, |
| {format: 'unorm16x4', offset: 1020, shaderLocation: 21}, |
| {format: 'uint32', offset: 3080, shaderLocation: 19}, |
| {format: 'unorm10-10-10-2', offset: 4140, shaderLocation: 18}, |
| {format: 'unorm16x4', offset: 5196, shaderLocation: 23}, |
| {format: 'float32x2', offset: 10132, shaderLocation: 20}, |
| {format: 'snorm8x2', offset: 5242, shaderLocation: 11}, |
| {format: 'snorm8x4', offset: 680, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let texture14 = device0.createTexture({ |
| size: {width: 176}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r32sint'], |
| }); |
| let textureView17 = texture7.createView({ |
| label: '\u{1fee7}\u5f00\u24c8\u1279\u03e8\ua28c', |
| dimension: '2d-array', |
| format: 'rgba8unorm', |
| baseMipLevel: 2, |
| }); |
| let computePassEncoder7 = commandEncoder13.beginComputePass({label: '\u16cf\u04c7\u{1fc46}\u{1faa1}\u3cbb\u376b\u231a\uf941\u019d\u01f8'}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| sampleCount: 1, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer3, 45468, buffer1, 321092, 64); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 4436, new DataView(new ArrayBuffer(2535)), 1751, 356); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video0, |
| origin: { x: 2, y: 7 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| gc(); |
| let videoFrame0 = new VideoFrame(canvas0, {timestamp: 0}); |
| let shaderModule1 = device0.createShaderModule({ |
| label: '\u040b\u306f\u01b8\u798b', |
| code: `@group(1) @binding(1494) |
| var<storage, read_write> global0: array<u32>; |
| @group(0) @binding(1530) |
| var<storage, read_write> global1: array<u32>; |
| @group(2) @binding(1494) |
| var<storage, read_write> local0: array<u32>; |
| |
| @compute @workgroup_size(1, 2, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S0 { |
| @builtin(position) f0: vec4<f32> |
| } |
| struct FragmentOutput0 { |
| @location(6) f0: i32, |
| @location(0) f1: vec3<u32>, |
| @location(2) f2: vec2<u32>, |
| @location(4) f3: vec4<f32>, |
| @location(1) f4: vec4<i32>, |
| @location(3) f5: i32 |
| } |
| |
| @fragment |
| fn fragment0(@location(54) a0: vec4<f16>, @location(36) a1: f32, @location(40) a2: f16, @builtin(front_facing) a3: bool, @builtin(sample_index) a4: u32, @builtin(sample_mask) a5: u32, a6: S0) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(54) f0: vec4<f16>, |
| @location(36) f1: f32, |
| @builtin(position) f2: vec4<f32>, |
| @location(40) f3: f16 |
| } |
| |
| @vertex |
| fn vertex0(@location(2) a0: vec4<f32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| let textureView18 = texture4.createView({}); |
| let renderBundle9 = renderBundleEncoder2.finish({label: '\u{1f97e}\udfbe\u0d67\u2405\u6ba2\u{1fad2}\u602f'}); |
| let pipeline15 = device0.createRenderPipeline({ |
| label: '\u7d1e\ud1e6\u1b5c\udb3c\u{1fcfb}', |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA}, {format: 'r16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'zero', dstFactor: 'dst-alpha'}, |
| }, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 3832, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm8x4', offset: 108, shaderLocation: 2}], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'ccw', unclippedDepth: true}, |
| }); |
| let texture15 = device0.createTexture({ |
| label: '\u0b41\u0892\u220f', |
| size: {width: 2388, height: 128, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint'], |
| }); |
| let textureView19 = texture0.createView({baseMipLevel: 4, baseArrayLayer: 533, arrayLayerCount: 92}); |
| let computePassEncoder8 = commandEncoder13.beginComputePass(); |
| let renderBundle10 = renderBundleEncoder0.finish({label: '\u{1fb95}\u4e18\u8eb7\u0163\ud43b\uc065\u3d79\u{1ffe6}\ua8b1\u38d7\u749e'}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder4.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup3, []); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(1, buffer3, 0, 14204); |
| } catch {} |
| let pipeline16 = await device0.createComputePipelineAsync({ |
| label: '\u5a35\u{1fcdb}\u244c\ueac8\u7b77\u{1f743}\u0d7d\u{1ffe4}\uf423', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule0, entryPoint: 'compute0'}, |
| }); |
| let commandEncoder16 = device0.createCommandEncoder({label: '\u0cf3\u0c88\u0b45\uc975\u49a8\u2847\u82b8\u0cac\u9e1c\u0861'}); |
| let texture16 = device0.createTexture({ |
| size: [640], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'], |
| }); |
| let renderBundle11 = renderBundleEncoder4.finish(); |
| let sampler11 = device0.createSampler({ |
| label: '\u1e76\u0025\u{1ff72}\u{1fce6}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 12, |
| }); |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer4, 121280, buffer0, 471780, 19048); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer0, 307844, 14076); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| offscreenCanvas4.getContext('bitmaprenderer'); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| label: '\u{1fb4f}\ue564\uade1', |
| code: `@group(2) @binding(1530) |
| var<storage, read_write> field0: array<u32>; |
| @group(1) @binding(1530) |
| var<storage, read_write> function2: array<u32>; |
| @group(0) @binding(1530) |
| var<storage, read_write> n0: array<u32>; |
| @group(3) @binding(1530) |
| var<storage, read_write> global2: array<u32>; |
| |
| @compute @workgroup_size(4, 2, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<i32>, |
| @location(0) f1: vec4<u32>, |
| @location(2) f2: vec3<u32>, |
| @location(3) f3: i32, |
| @location(4) f4: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(sample_index) a1: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(6) a0: vec4<f32>, @location(13) a1: i32, @location(18) a2: vec2<f16>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let texture17 = device0.createTexture({ |
| label: '\ue71c\u4ba3\u714d\u4540\uf7f0', |
| size: {width: 176, height: 96, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let texture18 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({ |
| label: '\u{1ff13}\u0eb1\u{1fa67}\ue13e\uc032\u093d\uec07', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| sampleCount: 1, |
| }); |
| let renderBundle12 = renderBundleEncoder10.finish({label: '\u9ed8\u7c2e\u3c0d\u127a'}); |
| let sampler12 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 60.09, |
| lodMaxClamp: 87.45, |
| }); |
| try { |
| computePassEncoder6.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 34 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 6720 */ |
| offset: 6720, |
| rowsPerImage: 278, |
| buffer: buffer1, |
| }, {width: 17, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| computePassEncoder3.pushDebugGroup('\u{1f7e4}'); |
| } catch {} |
| let img0 = await imageWithData(133, 120, '#e1a3942b', '#b482a3e0'); |
| let bindGroup4 = device0.createBindGroup({ |
| label: '\u{1f861}\u{1f6e1}\u34c8\u{1fda2}\ua2b5\u3142\ua425\u{1fcd5}\u{1fe88}\u01f6', |
| layout: bindGroupLayout1, |
| entries: [{binding: 1494, resource: sampler4}], |
| }); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let texture19 = device0.createTexture({ |
| label: '\u{1fe37}\u{1f7e7}\u0cc9\ub730\u12db\ud146\uf2a3\u070a', |
| size: [320, 40, 1], |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb'], |
| }); |
| let textureView20 = texture4.createView({label: '\ua0dd\u{1f75c}\u0e85\u4c08'}); |
| let computePassEncoder9 = commandEncoder17.beginComputePass(); |
| let externalTexture4 = device0.importExternalTexture({label: '\u0233\u{1ff06}\u0208\u3330\u05da\uedf7\ua587\u07d3\u0d60\u0501\u0afa', source: videoFrame0}); |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup2, new Uint32Array(4311), 3943, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(4, buffer3, 43572, 2678); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer3, 28112, buffer0, 471208, 15032); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 22108, new DataView(new ArrayBuffer(57179)), 49872, 720); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas4, |
| origin: { x: 67, y: 19 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline17 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}}); |
| try { |
| await promise2; |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let imageData1 = new ImageData(52, 256); |
| try { |
| canvas1.getContext('webgpu'); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| label: '\u4ebd\ua612\u0b85\u1c3c\ua490\ua7e4\u344a\u0b65\u5d6b\u{1fceb}\uf896', |
| layout: bindGroupLayout3, |
| entries: [{binding: 6255, resource: sampler1}], |
| }); |
| let commandEncoder18 = device0.createCommandEncoder({label: '\u0dab\u3f87\u82f0\u{1f738}\u0bf6\u20ea\u05d5\uaef2\u0741'}); |
| let texture20 = device0.createTexture({ |
| label: '\u9fa8\ub450', |
| size: {width: 22}, |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let textureView21 = texture6.createView({label: '\u0781\u7f66\uc90b\u0495\u{1f9e6}\u0d21\uba59\u704b\ub88d', dimension: '2d-array'}); |
| let renderBundle13 = renderBundleEncoder10.finish({label: '\u0ea0\u{1fae5}\u6a3a\uf61b\u{1feca}'}); |
| let externalTexture5 = device0.importExternalTexture({ |
| label: '\ub27d\u77b0\u9f61\u0044\u0e52\u648b\u{1fef4}\u0723\u682b\u{1fbe0}', |
| source: video0, |
| colorSpace: 'srgb', |
| }); |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(6929), 2188, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline0); |
| } catch {} |
| let pipeline18 = device0.createRenderPipeline({ |
| label: '\u0b4a\u0278\u48f2\u29cc\u{1fddc}\u079d\u0cca\u8483\uea25', |
| layout: 'auto', |
| multisample: {mask: 0x596e6eac}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rg16sint', writeMask: 0}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rgba8unorm-srgb'}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 4508, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 196, shaderLocation: 13}, |
| {format: 'float16x2', offset: 396, shaderLocation: 18}, |
| ], |
| }, |
| { |
| arrayStride: 16184, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm16x4', offset: 3588, shaderLocation: 6}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| document.body.prepend(video0); |
| let video2 = await videoWithData(); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let commandBuffer9 = commandEncoder18.finish({}); |
| let texture21 = device0.createTexture({ |
| label: '\u5b5b\u2f28\u0c95\u{1faee}\u457a\u0486\u{1fc5b}\u32e9', |
| size: [160], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture22 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView22 = texture3.createView({label: '\u61b6\u0d0e\ucd8b\u221c\u3b1d\u463f\u49bc\ua25a', dimension: '2d-array', mipLevelCount: 3}); |
| let externalTexture6 = device0.importExternalTexture({source: video1, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 43140 */ |
| offset: 43140, |
| rowsPerImage: 3, |
| buffer: buffer3, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline19 = await device0.createRenderPipelineAsync({ |
| label: '\ua9a1\uafe8\u{1ffa4}', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rg16sint', writeMask: GPUColorWrite.GREEN}, {format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'dst'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'constant'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 23956, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32x3', offset: 4452, shaderLocation: 13}, |
| {format: 'snorm8x2', offset: 5536, shaderLocation: 18}, |
| ], |
| }, |
| {arrayStride: 9780, attributes: []}, |
| {arrayStride: 1492, attributes: [{format: 'float32', offset: 384, shaderLocation: 6}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true}, |
| }); |
| try { |
| await promise5; |
| } catch {} |
| let img1 = await imageWithData(72, 294, '#076bf94a', '#19693504'); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], depthReadOnly: true}); |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 2, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 60 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5276 */ |
| offset: 4192, |
| bytesPerRow: 512, |
| rowsPerImage: 104, |
| buffer: buffer1, |
| }, {width: 30, height: 3, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 180, y: 102 }, |
| flipY: false, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline20 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}}}); |
| let bindGroup6 = device0.createBindGroup({ |
| label: '\uc06b\u053b\ub658\u0124', |
| layout: bindGroupLayout0, |
| entries: [{binding: 1530, resource: externalTexture4}], |
| }); |
| let texture23 = device0.createTexture({ |
| label: '\u06f8\u{1f7f2}\u{1f634}\u0125\u9b8f', |
| size: [88], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg8uint'], |
| }); |
| try { |
| computePassEncoder5.setPipeline(pipeline20); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 44756 */ |
| offset: 44756, |
| buffer: buffer3, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder19.copyTextureToBuffer({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 21540 */ |
| offset: 21540, |
| buffer: buffer1, |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipeline21 = await device0.createRenderPipelineAsync({ |
| label: '\u{1faa6}\u{1ffbb}', |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x15a031f4}, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.RED}, {format: 'rg16sint'}, { |
| format: 'r16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'add', srcFactor: 'zero', dstFactor: 'src-alpha-saturated'}, |
| alpha: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [{arrayStride: 5320, attributes: [{format: 'float32x4', offset: 3900, shaderLocation: 2}]}], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let video3 = await videoWithData(); |
| try { |
| canvas0.getContext('2d'); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder({label: '\u0c77\u525c\u41ff\ubf37\u0fc8\u7019\u0b3f\u{1ffce}'}); |
| let computePassEncoder10 = commandEncoder16.beginComputePass({label: '\u{1fe30}\u{1ff6b}\u6aa0\u{1f9d0}\u007d\u9521\u3de3\u{1f773}\u5b08'}); |
| try { |
| renderBundleEncoder8.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer3, 0); |
| } catch {} |
| try { |
| commandEncoder20.copyTextureToBuffer({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 608 widthInBlocks: 152 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 32888 */ |
| offset: 32280, |
| buffer: buffer1, |
| }, {width: 152, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| label: '\u02e5\u0228\u0b3e\u0415\u3ac2\u80ea\u7934\u02ed', |
| code: `@group(2) @binding(1494) |
| var<storage, read_write> local1: array<u32>; |
| @group(1) @binding(1494) |
| var<storage, read_write> function3: array<u32>; |
| |
| @compute @workgroup_size(2, 3, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(2) f0: vec3<u32>, |
| @location(0) f1: vec3<u32>, |
| @builtin(sample_mask) f2: u32, |
| @location(3) f3: vec2<i32>, |
| @location(1) f4: vec3<i32>, |
| @location(6) f5: vec3<u32>, |
| @location(4) f6: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S1 { |
| @location(22) f0: vec4<i32>, |
| @location(16) f1: u32, |
| @builtin(vertex_index) f2: u32, |
| @location(19) f3: vec2<f32> |
| } |
| |
| @vertex |
| fn vertex0(a0: S1, @location(11) a1: f32, @location(23) a2: vec2<f32>, @location(13) a3: vec4<u32>, @location(5) a4: vec2<u32>, @location(14) a5: vec2<u32>, @location(6) a6: vec2<u32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let textureView23 = texture16.createView({label: '\uf731\u{1fc9f}\u6a49\u{1f9a7}\u4fee', baseArrayLayer: 0}); |
| let computePassEncoder11 = commandEncoder20.beginComputePass({label: '\u7ed5\u3e05\u027a\u06fb\u05ee\ua2dc'}); |
| try { |
| computePassEncoder10.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(4, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(9, buffer3); |
| } catch {} |
| let pipeline22 = device0.createComputePipeline({ |
| label: '\u{1fe77}\u7ac4\u2750', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}}, |
| }); |
| let bindGroup7 = device0.createBindGroup({label: '\u39e5\u08bf\ucfd0', layout: bindGroupLayout3, entries: [{binding: 6255, resource: sampler4}]}); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 126}); |
| let commandBuffer10 = commandEncoder19.finish({label: '\u97b9\ub731\u7492\u{1ff26}\ub0dc\u05de'}); |
| let textureView24 = texture19.createView({label: '\u{1ffee}\u24cb', dimension: '2d-array'}); |
| let externalTexture7 = device0.importExternalTexture({ |
| label: '\u605c\u{1f72b}\u61ec\ue92f\u{1fc79}\u66af\u{1fd2c}\u7d86\ud7cb', |
| source: videoFrame0, |
| colorSpace: 'srgb', |
| }); |
| try { |
| computePassEncoder6.setBindGroup(5, bindGroup6, new Uint32Array(5026), 2645, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(4, bindGroup7); |
| } catch {} |
| let pipeline23 = device0.createComputePipeline({ |
| label: '\ucd89\u{1fe1c}\u{1ff3c}\u00fd\u5a5f\u0c6b\u0827\ub472\u0efa', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline24 = device0.createRenderPipeline({ |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0x89cd7ddb}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rg16sint'}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb'}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 4432, |
| stepMode: 'vertex', |
| attributes: [{format: 'unorm16x4', offset: 3484, shaderLocation: 6}], |
| }, |
| { |
| arrayStride: 21588, |
| stepMode: 'vertex', |
| attributes: [{format: 'sint32x2', offset: 15100, shaderLocation: 13}], |
| }, |
| { |
| arrayStride: 7612, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x2', offset: 724, shaderLocation: 18}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'ccw', unclippedDepth: false}, |
| }); |
| let video4 = await videoWithData(); |
| let imageData2 = new ImageData(252, 116); |
| let commandEncoder21 = device0.createCommandEncoder({label: '\u{1fe93}\u0ceb\u{1f794}\ub0bb'}); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({ |
| label: '\uf512\u{1fc7a}\u9c32\u75e6\u520c\u{1ff87}\u004a\ufbf8', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| }); |
| try { |
| computePassEncoder10.setBindGroup(5, bindGroup0, []); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer3); |
| } catch {} |
| let offscreenCanvas5 = new OffscreenCanvas(527, 795); |
| let computePassEncoder12 = commandEncoder21.beginComputePass(); |
| try { |
| computePassEncoder12.setBindGroup(6, bindGroup6, []); |
| } catch {} |
| try { |
| computePassEncoder3.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9, commandBuffer3]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 62492, new Float32Array(26556), 24599, 1316); |
| } catch {} |
| let pipeline25 = await device0.createComputePipelineAsync({ |
| label: '\u1d2b\u138a', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let commandEncoder22 = device0.createCommandEncoder({label: '\u{1fbd3}\u352a\ue572\u8431\u{1fa9f}\u1041\u0b67'}); |
| let textureView25 = texture9.createView({label: '\u02b4\u43b8\u3480\u7e55\u14bb\u8a30\u{1f822}\u01de\u09fb\u0980', baseArrayLayer: 0}); |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(4, bindGroup3, new Uint32Array(5708), 3303, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(504, undefined); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToBuffer(buffer2, 183468, buffer0, 152780, 171960); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| renderBundleEncoder12.pushDebugGroup('\u0ea8'); |
| } catch {} |
| let pipeline26 = device0.createComputePipeline({ |
| label: '\u09df\u55c4\udd22\ub461\u5be1\u099d\u00a1\u0456\u{1fbec}\u0fb9', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline27 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout0, |
| multisample: {mask: 0x4004a474}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.BLUE}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, { |
| format: 'r32sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'one-minus-src'}, |
| }, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 24972, attributes: []}, |
| { |
| arrayStride: 1540, |
| attributes: [ |
| {format: 'float32', offset: 728, shaderLocation: 18}, |
| {format: 'float32x2', offset: 440, shaderLocation: 6}, |
| {format: 'sint32x2', offset: 436, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'ccw', unclippedDepth: true}, |
| }); |
| let commandEncoder23 = device0.createCommandEncoder(); |
| let texture24 = device0.createTexture({ |
| label: '\u878a\u0b55\ue880\u0e07\u9df1\u5ef6\uf7cd\u079f', |
| size: {width: 1194}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16uint', 'r16uint'], |
| }); |
| let textureView26 = texture1.createView({label: '\u0723\uf696\u{1fbae}\u0781\u0a60\u2b2a\u00ab'}); |
| let renderBundle14 = renderBundleEncoder9.finish(); |
| let sampler13 = device0.createSampler({ |
| label: '\u0777\u05e0', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 23.82, |
| maxAnisotropy: 11, |
| }); |
| try { |
| renderBundleEncoder8.setBindGroup(4, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline14); |
| } catch {} |
| let arrayBuffer0 = buffer0.getMappedRange(82352, 9028); |
| try { |
| commandEncoder22.copyBufferToBuffer(buffer2, 532384, buffer0, 249800, 44760); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 11716 */ |
| offset: 11712, |
| buffer: buffer3, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline28 = device0.createComputePipeline({ |
| label: '\u0ae0\ua69f\u0975\u40ce\u56ae', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline29 = device0.createRenderPipeline({ |
| label: '\u0e96\u013a\u{1fe50}\u1f44\u{1f98d}\u0c38\u81a4', |
| layout: pipelineLayout2, |
| multisample: {mask: 0xa8f3e2fc}, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint'}, {format: 'r16uint'}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb'}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthCompare: 'always', |
| stencilFront: {compare: 'equal', failOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'never', failOp: 'invert', passOp: 'increment-clamp'}, |
| stencilReadMask: 2441343391, |
| stencilWriteMask: 3222705127, |
| depthBiasSlopeScale: 526.0234114475494, |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 27896, stepMode: 'vertex', attributes: []}, |
| { |
| arrayStride: 3836, |
| attributes: [ |
| {format: 'float16x2', offset: 1580, shaderLocation: 19}, |
| {format: 'unorm10-10-10-2', offset: 464, shaderLocation: 23}, |
| {format: 'uint32x2', offset: 2328, shaderLocation: 16}, |
| {format: 'snorm16x4', offset: 68, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 324, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 4368, |
| attributes: [ |
| {format: 'sint32', offset: 280, shaderLocation: 22}, |
| {format: 'uint32x3', offset: 284, shaderLocation: 14}, |
| {format: 'uint16x2', offset: 424, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 2164, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let videoFrame1 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup5, new Uint32Array(921), 431, 0); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 9944 */ |
| offset: 688, |
| bytesPerRow: 256, |
| buffer: buffer3, |
| }, { |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 51, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 37, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder22.clearBuffer(buffer1, 22836, 263660); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 148, y: 7 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture25 = device0.createTexture({ |
| label: '\u{1fd08}\u{1fc63}\u0940', |
| size: {width: 1194, height: 64, depthOrArrayLayers: 166}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let textureView27 = texture24.createView({label: '\u{1f9fa}\u0720\u66f3\u087b\u0ab9\u0a0b\u{1f838}\u{1fdfd}'}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({ |
| label: '\u2c54\u{1fcf7}\u4c4e', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: false, |
| }); |
| try { |
| commandEncoder22.copyBufferToBuffer(buffer4, 181564, buffer0, 499080, 13916); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 892 */ |
| offset: 892, |
| buffer: buffer3, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let video5 = await videoWithData(); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout3, bindGroupLayout2, bindGroupLayout0, bindGroupLayout3]}); |
| let commandEncoder24 = device0.createCommandEncoder({label: '\u{1fcc9}\u4bf5\u{1f803}\u5ff1\u0c75\u464f\u{1ff93}\u6d63\u8545'}); |
| let commandBuffer11 = commandEncoder24.finish({label: '\u00ab\uc3d9'}); |
| let texture26 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView28 = texture0.createView({dimension: '2d', baseMipLevel: 3, baseArrayLayer: 110}); |
| let externalTexture8 = device0.importExternalTexture({source: video2, colorSpace: 'srgb'}); |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder23.clearBuffer(buffer1, 199700, 113412); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 0, new Float32Array(14579), 9254, 516); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame2 = new VideoFrame(img0, {timestamp: 0}); |
| let commandEncoder25 = device0.createCommandEncoder({label: '\u5dec\u9690\u0c59'}); |
| let texture27 = device0.createTexture({ |
| size: [22, 12, 95], |
| mipLevelCount: 3, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView29 = texture16.createView({label: '\u0372\u9503\u3158', arrayLayerCount: 1}); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({ |
| label: '\u0287\u0237\uca71\u{1f963}\u0e6d\u0608\u{1fc72}\u18c3\u88ff', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| }); |
| try { |
| renderBundleEncoder5.setPipeline(pipeline19); |
| } catch {} |
| try { |
| commandEncoder14.clearBuffer(buffer0, 73408, 197652); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 458, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer0), /* required buffer size: 111 */ |
| {offset: 111}, {width: 133, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 522, y: 608 }, |
| flipY: true, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder({label: '\u{1fe1d}\u{1fa0b}\u0160\u6279\u0281\u{1fde8}\u2fe0\u09c7'}); |
| try { |
| renderBundleEncoder13.setBindGroup(4, bindGroup6, new Uint32Array(1850), 116, 0); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7, commandBuffer4]); |
| } catch {} |
| let externalTexture9 = device0.importExternalTexture({ |
| label: '\ubc54\ud0a9\u{1f815}\u039b\u19d9\u01ed\uab0e\u0c29\ufd77\u05b0\ue6f9', |
| source: videoFrame0, |
| colorSpace: 'srgb', |
| }); |
| try { |
| renderBundleEncoder5.setBindGroup(4, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(3, buffer3, 44032); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2412 */ |
| offset: 2412, |
| rowsPerImage: 119, |
| buffer: buffer3, |
| }, { |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0, commandBuffer8, commandBuffer6, commandBuffer11]); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let canvas3 = document.createElement('canvas'); |
| let buffer5 = device0.createBuffer({size: 135990, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder27 = device0.createCommandEncoder({label: '\u328d\u0237\ueaed'}); |
| let renderBundle15 = renderBundleEncoder10.finish({label: '\u30fa\u937e\u{1f736}\u08af\u7e55\u018a\u{1ff43}\u4d0c\uc777\ub55d'}); |
| try { |
| computePassEncoder4.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(6, buffer3, 10032, 10496); |
| } catch {} |
| try { |
| commandEncoder26.copyTextureToBuffer({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 7060 */ |
| offset: 7060, |
| buffer: buffer1, |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 192, y: 23 }, |
| flipY: false, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline30 = device0.createRenderPipeline({ |
| label: '\u{1f710}\u{1f88f}', |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r32sint'}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilFront: {compare: 'not-equal', failOp: 'zero', passOp: 'invert'}, |
| stencilBack: {failOp: 'decrement-clamp', passOp: 'invert'}, |
| stencilReadMask: 970657061, |
| stencilWriteMask: 1484594323, |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 1340, |
| attributes: [ |
| {format: 'uint8x4', offset: 8, shaderLocation: 6}, |
| {format: 'uint16x2', offset: 1336, shaderLocation: 5}, |
| {format: 'uint16x4', offset: 96, shaderLocation: 13}, |
| {format: 'uint32x4', offset: 184, shaderLocation: 16}, |
| {format: 'unorm10-10-10-2', offset: 740, shaderLocation: 23}, |
| ], |
| }, |
| { |
| arrayStride: 45740, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint8x4', offset: 7708, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 9072, shaderLocation: 11}, |
| {format: 'sint32x4', offset: 236, shaderLocation: 22}, |
| {format: 'unorm8x2', offset: 13840, shaderLocation: 19}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let commandEncoder28 = device0.createCommandEncoder({label: '\u8156\ud2ca\u0de0\u7994'}); |
| let texture28 = device0.createTexture({ |
| label: '\u087c\uc6d2\u{1fc3c}\u0452\u069b\u02cd\u{1f88f}', |
| size: [1280, 160, 38], |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let texture29 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder11.setBindGroup(5, bindGroup6, new Uint32Array(3834), 679, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(2, buffer3, 0); |
| } catch {} |
| let arrayBuffer1 = buffer2.getMappedRange(103128, 296); |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let pipeline31 = device0.createRenderPipeline({ |
| label: '\u{1fd95}\u{1f852}\u38d9\uc191', |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'add', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilFront: {compare: 'equal', failOp: 'increment-wrap', depthFailOp: 'replace', passOp: 'invert'}, |
| stencilBack: {compare: 'not-equal', failOp: 'increment-clamp', passOp: 'zero'}, |
| stencilReadMask: 2105322046, |
| stencilWriteMask: 2882327752, |
| depthBias: 1871615120, |
| depthBiasSlopeScale: 154.98144447893523, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 17420, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x2', offset: 10992, shaderLocation: 2}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let img2 = await imageWithData(274, 46, '#c6585c68', '#1be6df1c'); |
| let bindGroupLayout4 = device0.createBindGroupLayout({ |
| label: '\u0f6c\u{1fb3f}', |
| entries: [ |
| { |
| binding: 4160, |
| visibility: 0, |
| storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| {binding: 5244, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 2527, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| let commandEncoder29 = device0.createCommandEncoder({label: '\u0376\u0071\u{1f651}\u5baa\ubf3c\u25e2'}); |
| let textureView30 = texture4.createView({ |
| label: '\u2505\ubeb3\u0979\u{1f961}\ufc9b\u{1ff25}', |
| aspect: 'all', |
| format: 'rg8uint', |
| arrayLayerCount: 1, |
| }); |
| let computePassEncoder13 = commandEncoder29.beginComputePass({label: '\ue86f\u{1f9b4}\u{1f78c}\u{1fe90}\u528f\ufb9e'}); |
| try { |
| renderBundleEncoder5.setVertexBuffer(1, buffer3, 0, 32448); |
| } catch {} |
| try { |
| commandEncoder22.copyBufferToBuffer(buffer5, 128900, buffer1, 71448, 3472); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| renderBundleEncoder12.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 109, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 48 */ |
| {offset: 48}, {width: 39, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 207, y: 110 }, |
| flipY: false, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline32 = await device0.createComputePipelineAsync({ |
| label: '\u{1f9a4}\u6335\uafd1\ucbdb\u{1f8ee}\u{1fcfb}\u04ef\ue07a\uddee\u56d7', |
| layout: pipelineLayout3, |
| compute: {module: shaderModule2, entryPoint: 'compute0'}, |
| }); |
| try { |
| await promise8; |
| } catch {} |
| try { |
| canvas2.getContext('webgl'); |
| } catch {} |
| let texture30 = device0.createTexture({ |
| label: '\u4176\ub4ce\ub2fc\u080b\u{1f926}\u{1ff6f}\uec70\u{1fdd0}\u0006\u5f17', |
| size: {width: 600, height: 96, depthOrArrayLayers: 195}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm'], |
| }); |
| let renderBundle16 = renderBundleEncoder6.finish(); |
| try { |
| renderBundleEncoder5.draw(983445413, 959863833, 588210028); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| let pipeline33 = device0.createRenderPipeline({ |
| label: '\u11be\u0591\u6fca\u0f55\ub716\u982b', |
| layout: pipelineLayout3, |
| multisample: {count: 4, mask: 0xbc3ec647}, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg16sint', writeMask: 0}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.ALL}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-constant', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'equal', |
| stencilFront: {compare: 'greater', failOp: 'zero', depthFailOp: 'increment-wrap'}, |
| stencilBack: {compare: 'greater', depthFailOp: 'increment-wrap', passOp: 'decrement-clamp'}, |
| stencilReadMask: 1809987209, |
| stencilWriteMask: 1781392148, |
| depthBias: -1294580409, |
| depthBiasSlopeScale: 0.0, |
| depthBiasClamp: 258.6703788004626, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [{arrayStride: 5380, attributes: [{format: 'unorm8x4', offset: 48, shaderLocation: 2}]}], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let imageData3 = new ImageData(180, 132); |
| let bindGroupLayout5 = device0.createBindGroupLayout({ |
| label: '\u364f\u09d4\u1a63\u0e24\u{1fcb8}', |
| entries: [ |
| {binding: 4420, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 981, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({ |
| label: '\u077e\u6e7a\u326b\u8c85\u{1fbb3}\u{1f683}\u4f40\u0e67\u0ef9\u04d3\u27d4', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| }); |
| let sampler14 = device0.createSampler({ |
| label: '\u{1fead}\u{1fe1b}', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 24.26, |
| lodMaxClamp: 30.48, |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup1); |
| } catch {} |
| let pipeline34 = device0.createComputePipeline({ |
| label: '\u3b13\u32cc\u66c5\u968d\u4e95\u0d0c', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule1, entryPoint: 'compute0'}, |
| }); |
| try { |
| await promise4; |
| } catch {} |
| let commandEncoder30 = device0.createCommandEncoder({label: '\u{1fa95}\u6523\u88c6\u2bac\u{1f79f}'}); |
| let textureView31 = texture20.createView({label: '\u{1ff4d}\uad02\ufe0e', aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder0.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(491716839, 336435239, 519526736, -1124731482); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 176 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 14008 */ |
| offset: 14008, |
| rowsPerImage: 276, |
| buffer: buffer5, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 27, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 44, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| commandEncoder26.copyTextureToBuffer({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 34, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 496 widthInBlocks: 124 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 41744 */ |
| offset: 41744, |
| buffer: buffer0, |
| }, {width: 124, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder14.clearBuffer(buffer0, 22028, 283388); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 58}, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 2858993 */ |
| {offset: 8, bytesPerRow: 401, rowsPerImage: 264}, {width: 160, height: 10, depthOrArrayLayers: 28}); |
| } catch {} |
| let texture31 = device0.createTexture({ |
| label: '\u6bf3\u5059\u0da9\u{1f9b1}\u0ff6\u0145\u{1fa41}', |
| size: {width: 640, height: 80, depthOrArrayLayers: 1097}, |
| mipLevelCount: 9, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let texture32 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({ |
| label: '\ueb8d\uae9e\u08a5\u01e9\uc0d3\u0202\u{1f6a3}\u2733\u5d3c\u60fb', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| }); |
| try { |
| renderBundleEncoder5.draw(54962106, 219595796, 559691461, 296991883); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(689085558, 304789818, 230161604, 642919033, 684088899); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 34484); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 22268 */ |
| offset: 22268, |
| bytesPerRow: 256, |
| rowsPerImage: 139, |
| buffer: buffer3, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder22.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 3, |
| origin: {x: 23, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 208 widthInBlocks: 104 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 61042 */ |
| offset: 20386, |
| bytesPerRow: 256, |
| rowsPerImage: 150, |
| buffer: buffer0, |
| }, {width: 104, height: 9, depthOrArrayLayers: 2}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 211, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture33 = device0.createTexture({ |
| size: {width: 88, height: 48, depthOrArrayLayers: 1213}, |
| mipLevelCount: 6, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let textureView32 = texture27.createView({ |
| label: '\u{1fc02}\uf762\u{1f84f}\u{1f964}\u01fa', |
| dimension: '2d', |
| baseMipLevel: 2, |
| mipLevelCount: 1, |
| baseArrayLayer: 44, |
| }); |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 198460); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 31476); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline27); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 49820 */ |
| offset: 49766, |
| buffer: buffer0, |
| }, {width: 27, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let imageData4 = new ImageData(24, 124); |
| try { |
| window.someLabel = texture1.label; |
| } catch {} |
| let pipelineLayout4 = device0.createPipelineLayout({ |
| label: '\u{1fa3a}\u3abe', |
| bindGroupLayouts: [bindGroupLayout1, bindGroupLayout5, bindGroupLayout5, bindGroupLayout5, bindGroupLayout2, bindGroupLayout3, bindGroupLayout5], |
| }); |
| let texture34 = device0.createTexture({ |
| label: '\u15ff\uf8dd\u{1f7fd}\uacc0\u0ac8\ud226', |
| size: {width: 298}, |
| dimension: '1d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder14 = commandEncoder26.beginComputePass({label: '\u53ef\u1034\u62ed\u7d3f\u{1ffef}\u043a\u0600\u5c36\uee5e\u3d34\u06dd'}); |
| try { |
| computePassEncoder9.end(); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(82888303, 569856819); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 57492); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(8, buffer3, 4596); |
| } catch {} |
| try { |
| await device0.popErrorScope(); |
| } catch {} |
| let buffer6 = device0.createBuffer({ |
| label: '\uec46\uf679\uc61c\u0f55\u4686\udbc5', |
| size: 248254, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| let texture35 = device0.createTexture({ |
| label: '\u{1fb9b}\ud460\u44c1\u0d82\u7386\u0be7\ua589', |
| size: {width: 640, height: 80, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let computePassEncoder15 = commandEncoder22.beginComputePass({label: '\u1a34\u{1f67e}'}); |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToBuffer(buffer2, 324868, buffer0, 315240, 164352); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let querySet6 = device0.createQuerySet({type: 'occlusion', count: 3460}); |
| try { |
| renderBundleEncoder8.setVertexBuffer(5, buffer3, 15756, 5299); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToBuffer(buffer5, 8412, buffer1, 70028, 10144); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 42 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 7530 */ |
| offset: 7530, |
| buffer: buffer0, |
| }, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder17.copyTextureToTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 33, y: 13, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture25, |
| mipLevel: 5, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 23, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 16, y: 138 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise10 = device0.createComputePipelineAsync({ |
| label: '\u0fda\u853f\u0907\u{1f6f7}\u549a', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| gc(); |
| let offscreenCanvas6 = new OffscreenCanvas(426, 281); |
| let shaderModule4 = device0.createShaderModule({ |
| label: '\u0ccc\u{1ff5e}\u827f\ub17c\ueeac\ua764\ue868', |
| code: `@group(1) @binding(1530) |
| var<storage, read_write> global3: array<u32>; |
| @group(2) @binding(1530) |
| var<storage, read_write> parameter0: array<u32>; |
| @group(3) @binding(1530) |
| var<storage, read_write> parameter1: array<u32>; |
| |
| @compute @workgroup_size(8, 3, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S2 { |
| @location(48) f0: vec3<f32>, |
| @location(74) f1: vec2<i32>, |
| @location(84) f2: vec4<u32>, |
| @location(49) f3: f16, |
| @location(21) f4: u32, |
| @location(13) f5: i32, |
| @location(70) f6: vec2<f16>, |
| @location(10) f7: vec2<u32>, |
| @location(46) f8: vec2<i32>, |
| @location(57) f9: vec2<f16>, |
| @location(1) f10: vec4<f16>, |
| @location(19) f11: u32, |
| @builtin(sample_mask) f12: u32, |
| @location(56) f13: u32, |
| @location(6) f14: f16, |
| @location(28) f15: vec2<u32>, |
| @builtin(front_facing) f16: bool, |
| @location(50) f17: vec3<f16>, |
| @location(2) f18: f16 |
| } |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<i32>, |
| @location(3) f1: vec3<i32>, |
| @location(2) f2: u32, |
| @location(4) f3: vec4<f32>, |
| @location(0) f4: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(a0: S2, @location(24) a1: vec2<f32>, @location(4) a2: vec2<f16>, @location(31) a3: vec3<u32>, @location(34) a4: vec4<f32>, @location(8) a5: vec3<u32>, @location(76) a6: vec2<i32>, @location(82) a7: vec4<i32>, @location(0) a8: vec3<u32>, @location(58) a9: vec4<f16>, @location(45) a10: f16, @location(55) a11: vec3<f16>, @location(39) a12: vec4<f16>, @location(37) a13: vec2<f16>, @location(65) a14: vec3<i32>, @location(77) a15: vec2<f16>, @location(83) a16: vec3<f32>, @location(36) a17: f32, @location(15) a18: vec3<i32>, @location(64) a19: i32, @location(80) a20: u32, @location(78) a21: vec3<f16>, @builtin(position) a22: vec4<f32>, @builtin(sample_index) a23: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(64) f4: i32, |
| @location(57) f5: vec2<f16>, |
| @location(6) f6: f16, |
| @location(34) f7: vec4<f32>, |
| @location(2) f8: f16, |
| @location(19) f9: u32, |
| @location(50) f10: vec3<f16>, |
| @location(28) f11: vec2<u32>, |
| @location(49) f12: f16, |
| @location(84) f13: vec4<u32>, |
| @location(45) f14: f16, |
| @location(21) f15: u32, |
| @location(1) f16: vec4<f16>, |
| @location(58) f17: vec4<f16>, |
| @location(76) f18: vec2<i32>, |
| @location(70) f19: vec2<f16>, |
| @location(13) f20: i32, |
| @location(36) f21: f32, |
| @builtin(position) f22: vec4<f32>, |
| @location(39) f23: vec4<f16>, |
| @location(31) f24: vec3<u32>, |
| @location(8) f25: vec3<u32>, |
| @location(10) f26: vec2<u32>, |
| @location(55) f27: vec3<f16>, |
| @location(82) f28: vec4<i32>, |
| @location(83) f29: vec3<f32>, |
| @location(78) f30: vec3<f16>, |
| @location(24) f31: vec2<f32>, |
| @location(65) f32: vec3<i32>, |
| @location(37) f33: vec2<f16>, |
| @location(0) f34: vec3<u32>, |
| @location(4) f35: vec2<f16>, |
| @location(48) f36: vec3<f32>, |
| @location(77) f37: vec2<f16>, |
| @location(74) f38: vec2<i32>, |
| @location(80) f39: u32, |
| @location(56) f40: u32, |
| @location(15) f41: vec3<i32>, |
| @location(46) f42: vec2<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(23) a0: vec4<u32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroupLayout6 = device0.createBindGroupLayout({label: '\u956f\u{1f8c5}\u{1fd93}', entries: []}); |
| let commandBuffer12 = commandEncoder25.finish({label: '\u{1fd77}\ue3f0\u0637\u0763'}); |
| let texture36 = device0.createTexture({ |
| label: '\u273d\ua1f9\u1633\u{1f886}\u2b3b\uedbc', |
| size: {width: 597, height: 32, depthOrArrayLayers: 459}, |
| mipLevelCount: 9, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView33 = texture2.createView({dimension: '2d-array', baseMipLevel: 2}); |
| let externalTexture10 = device0.importExternalTexture({label: '\u999d\u4cb3\u7bd1\u1994\u{1f853}\uc156', source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder8.draw(737298919, 271213432, 963128296, 1016383155); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(235478045, 64728679, 380624097, -478791665, 580107093); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer1, 67528); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 11216); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 23064 */ |
| offset: 23064, |
| rowsPerImage: 205, |
| buffer: buffer5, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| let buffer7 = device0.createBuffer({ |
| label: '\u1297\u{1fb10}\u02db\u32a7', |
| size: 6723, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({ |
| label: '\u8446\u8e55\u08f1\ud55b\uf130\u{1fb4d}\u47f6\ud41d\u06d9\u0824', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: true, |
| }); |
| let externalTexture11 = device0.importExternalTexture({label: '\u9b0c\u5faf', source: video4}); |
| try { |
| computePassEncoder4.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(51166306, 410092748); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer1, 23992); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToBuffer({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5160 */ |
| offset: 5160, |
| bytesPerRow: 256, |
| buffer: buffer0, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 3, y: 17 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas5.getContext('webgpu'); |
| let textureView34 = texture33.createView({dimension: '2d', baseMipLevel: 5, baseArrayLayer: 506}); |
| let computePassEncoder16 = commandEncoder14.beginComputePass({label: '\u0911\u64d1\ubc29\u09d9\uf96d'}); |
| let externalTexture12 = device0.importExternalTexture({label: '\uf89d\u{1f760}\u8bf7\u72e7\u0614\u97b6\u065f', source: video1, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 63856); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline27); |
| } catch {} |
| let pipeline35 = await promise10; |
| gc(); |
| let buffer8 = device0.createBuffer({ |
| size: 167149, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundle17 = renderBundleEncoder11.finish({label: '\uff37\u7a4a\u4370\u0b75\u{1ffc5}\u0176\u00f9\u2fd2\u0d90'}); |
| try { |
| renderBundleEncoder8.drawIndexed(1060892158, 809854819, 4565386, 162921797, 1129575559); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToBuffer(buffer6, 138432, buffer1, 358816, 684); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5120 */ |
| offset: 5120, |
| buffer: buffer3, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder28.copyTextureToTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 151, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 464, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 136, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 832, new DataView(new ArrayBuffer(54246)), 6229, 588); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView35 = texture3.createView({ |
| label: '\u5a73\u01d3\u0e62\u0e7b\u0f17\ue271\u1cce\u{1fff7}\u0b17', |
| dimension: '2d-array', |
| baseMipLevel: 1, |
| mipLevelCount: 2, |
| }); |
| let computePassEncoder17 = commandEncoder30.beginComputePass({label: '\u5d88\u78bc\u29fd\u460f\u07cc\u096c\u534e\u1172'}); |
| try { |
| renderBundleEncoder12.setBindGroup(5, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder8.draw(345981025, 1144391419); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas5, |
| origin: { x: 97, y: 179 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline36 = device0.createComputePipeline({ |
| label: '\ucfd3\u{1f7f6}\u0053\u7222', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule4, entryPoint: 'compute0'}, |
| }); |
| let textureView36 = texture21.createView({label: '\ufb84\u34c5\u413f\u8bc4\ucbfd\u{1ffb3}\u0976\u0332\u9494\u087a\u6641', mipLevelCount: 1}); |
| let externalTexture13 = device0.importExternalTexture({ |
| label: '\u0819\u7e4b\u0fa5\u4308\u6f07\u095c\u0697\u1e3c\u0645', |
| source: video1, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| renderBundleEncoder17.setVertexBuffer(3, buffer3, 0, 31918); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| label: '\u281f\u857f', |
| code: `@group(0) @binding(6255) |
| var<storage, read_write> n1: array<u32>; |
| @group(3) @binding(6255) |
| var<storage, read_write> local2: array<u32>; |
| @group(1) @binding(2593) |
| var<storage, read_write> function4: array<u32>; |
| |
| @compute @workgroup_size(7, 4, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S3 { |
| @location(62) f0: vec3<f32>, |
| @location(8) f1: u32, |
| @location(43) f2: vec3<u32>, |
| @location(74) f3: vec2<u32>, |
| @location(33) f4: vec2<f32>, |
| @location(42) f5: vec3<u32>, |
| @location(5) f6: vec2<f16>, |
| @location(19) f7: f32, |
| @location(24) f8: vec3<u32>, |
| @location(16) f9: vec4<u32>, |
| @location(70) f10: vec3<i32>, |
| @location(22) f11: vec2<i32>, |
| @location(67) f12: vec4<f32>, |
| @location(13) f13: vec4<i32>, |
| @location(50) f14: vec2<i32> |
| } |
| struct FragmentOutput0 { |
| @location(3) f0: vec3<i32>, |
| @location(0) f1: vec4<u32>, |
| @location(1) f2: vec3<i32>, |
| @location(4) f3: vec4<f32>, |
| @location(2) f4: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(11) a0: vec2<f32>, @location(68) a1: vec2<u32>, a2: S3, @location(64) a3: i32, @location(84) a4: vec4<f16>, @location(18) a5: vec4<i32>, @builtin(position) a6: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(16) f43: vec4<u32>, |
| @location(70) f44: vec3<i32>, |
| @location(68) f45: vec2<u32>, |
| @location(33) f46: vec2<f32>, |
| @location(19) f47: f32, |
| @location(13) f48: vec4<i32>, |
| @location(22) f49: vec2<i32>, |
| @location(50) f50: vec2<i32>, |
| @location(84) f51: vec4<f16>, |
| @location(74) f52: vec2<u32>, |
| @location(43) f53: vec3<u32>, |
| @location(5) f54: vec2<f16>, |
| @location(8) f55: u32, |
| @location(11) f56: vec2<f32>, |
| @location(64) f57: i32, |
| @location(18) f58: vec4<i32>, |
| @builtin(position) f59: vec4<f32>, |
| @location(42) f60: vec3<u32>, |
| @location(24) f61: vec3<u32>, |
| @location(67) f62: vec4<f32>, |
| @location(62) f63: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(1) a0: f32, @location(23) a1: vec2<f32>, @location(12) a2: vec4<f32>, @location(10) a3: vec3<i32>, @location(19) a4: vec2<u32>, @location(20) a5: vec4<i32>, @location(18) a6: vec3<f32>, @location(16) a7: vec4<i32>, @location(13) a8: u32, @location(3) a9: i32, @location(7) a10: u32, @location(0) a11: u32, @location(2) a12: vec4<i32>, @location(21) a13: f16) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| }); |
| let commandEncoder31 = device0.createCommandEncoder(); |
| let querySet7 = device0.createQuerySet({label: '\uc082\u{1fca1}\uc299\u000d\uaade\ufbf3\u7312\ue9ff\u0411', type: 'occlusion', count: 3731}); |
| let textureView37 = texture29.createView({label: '\ub5d5\u0307\ucf5f\ufc14', dimension: '2d-array'}); |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 11648); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer1, 60132); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer8, 'uint16', 111246, 52673); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(9, buffer8, 0, 55660); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer0, 209396, 22564); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| renderBundleEncoder3.insertDebugMarker('\u61d1'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| offscreenCanvas6.getContext('bitmaprenderer'); |
| } catch {} |
| let commandEncoder32 = device0.createCommandEncoder(); |
| let texture37 = device0.createTexture({ |
| label: '\u0df3\u{1f783}\u{1ff35}\u{1f8c0}\u{1fddf}\ua56d\u{1f967}', |
| size: {width: 600, height: 96, depthOrArrayLayers: 1643}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture14 = device0.importExternalTexture({label: '\u06c7\u9b66\u9a20\uce46\ud44c\u{1fa3e}\u6713', source: video0, colorSpace: 'display-p3'}); |
| try { |
| renderBundleEncoder8.drawIndexed(601542701, 457798787, 638725251, -465895016, 657157726); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer8, 'uint32', 40152, 6867); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline8); |
| } catch {} |
| try { |
| buffer5.destroy(); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: {x: 126, y: 4, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 83, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 143, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new ArrayBuffer(229234), /* required buffer size: 229234 */ |
| {offset: 818, bytesPerRow: 276, rowsPerImage: 162}, {width: 41, height: 18, depthOrArrayLayers: 6}); |
| } catch {} |
| let commandEncoder33 = device0.createCommandEncoder({label: '\u32d4\u4692\u{1f93a}\u{1f79d}\u{1f799}\u{1feee}\u486f'}); |
| let texture38 = device0.createTexture({ |
| label: '\u7d73\uf1fc\u07ab\u2e1b\u{1fb08}\ud11b\u0f99\u{1ff86}\u5643\u6da9', |
| size: [44, 24, 1], |
| mipLevelCount: 4, |
| format: 'eac-rg11unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['eac-rg11unorm'], |
| }); |
| let textureView38 = texture25.createView({label: '\u{1fd21}\ud6c5\u{1f956}\u38f5', baseMipLevel: 6}); |
| let renderBundle18 = renderBundleEncoder6.finish({}); |
| let externalTexture15 = device0.importExternalTexture({label: '\u5701\u2989\u3556\u0dd6', source: videoFrame2}); |
| try { |
| computePassEncoder14.setBindGroup(4, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer8, 71092); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToBuffer(buffer6, 108440, buffer0, 257108, 54540); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer1, 132296, 141924); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let pipeline37 = device0.createComputePipeline({ |
| label: '\ubd3c\u{1f8f3}\ueb4b', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}}, |
| }); |
| let textureView39 = texture22.createView({label: '\ua963\u0020\u15f3\u7dbb\u0d24\u022c\u3b77\u1a86\ub121\u8a0a', baseArrayLayer: 0}); |
| let externalTexture16 = device0.importExternalTexture({ |
| label: '\u8096\u7f80\u0456\uabd2\u{1ff67}\u{1f910}\u7210\u{1ff72}\ufe52\u{1ff40}\u0ff9', |
| source: videoFrame2, |
| colorSpace: 'srgb', |
| }); |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer1, 187180); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 106712); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToBuffer({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 15, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 204 widthInBlocks: 51 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 7260 */ |
| offset: 7260, |
| buffer: buffer0, |
| }, {width: 51, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder23.clearBuffer(buffer0, 347584, 92016); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| renderBundleEncoder5.insertDebugMarker('\udfcc'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas3, |
| origin: { x: 20, y: 48 }, |
| flipY: false, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture39 = device0.createTexture({ |
| label: '\uc9cf\u14bc\u58f5', |
| size: [640, 80, 1], |
| mipLevelCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'], |
| }); |
| let textureView40 = texture6.createView({label: '\u25f6\u{1fcac}\u45ef', dimension: '2d-array', baseArrayLayer: 0, arrayLayerCount: 1}); |
| let computePassEncoder18 = commandEncoder28.beginComputePass({}); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({ |
| label: '\u56f6\ua1bf', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(4, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(119725772, 365674369); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToBuffer(buffer2, 299900, buffer0, 511608, 1912); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let commandEncoder34 = device0.createCommandEncoder(); |
| let renderBundle19 = renderBundleEncoder16.finish({label: '\u04df\u1e00\ubc3a\u0aee'}); |
| try { |
| renderBundleEncoder8.drawIndexed(168870587, 472084291, 680565792); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder33.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 98, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 996 widthInBlocks: 249 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 23188 */ |
| offset: 23188, |
| buffer: buffer0, |
| }, {width: 249, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer0, 255912, 212408); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video2, |
| origin: { x: 1, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline38 = await device0.createRenderPipelineAsync({ |
| label: '\uae3c\ue9cd\u12b6\u0b3b\u0cb8', |
| layout: pipelineLayout4, |
| multisample: {mask: 0x34f4c7a9}, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg16sint'}, {format: 'r16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, { |
| format: 'r32sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'never', |
| stencilFront: {compare: 'always', failOp: 'keep', depthFailOp: 'increment-clamp', passOp: 'keep'}, |
| stencilBack: {failOp: 'invert', passOp: 'increment-clamp'}, |
| stencilReadMask: 4294967295, |
| stencilWriteMask: 3103795284, |
| depthBias: 33528475, |
| depthBiasSlopeScale: 994.598385409595, |
| depthBiasClamp: 0.0, |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 0, attributes: []}, |
| { |
| arrayStride: 2072, |
| attributes: [ |
| {format: 'uint8x2', offset: 158, shaderLocation: 16}, |
| {format: 'float32x4', offset: 796, shaderLocation: 11}, |
| {format: 'float32x2', offset: 860, shaderLocation: 19}, |
| {format: 'uint32x2', offset: 1184, shaderLocation: 14}, |
| {format: 'float16x2', offset: 780, shaderLocation: 23}, |
| {format: 'sint8x2', offset: 574, shaderLocation: 22}, |
| {format: 'uint32x2', offset: 84, shaderLocation: 6}, |
| {format: 'uint16x2', offset: 444, shaderLocation: 13}, |
| {format: 'uint8x4', offset: 992, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let gpuCanvasContext3 = canvas3.getContext('webgpu'); |
| document.body.prepend(video2); |
| let textureView41 = texture13.createView({ |
| label: '\ufb66\u8720', |
| format: 'astc-5x4-unorm', |
| baseMipLevel: 5, |
| mipLevelCount: 1, |
| baseArrayLayer: 50, |
| arrayLayerCount: 4, |
| }); |
| try { |
| renderBundleEncoder5.draw(805328140, 978552115, 53116069, 410608525); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 15724); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 8728 */ |
| offset: 8728, |
| rowsPerImage: 133, |
| buffer: buffer5, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| commandEncoder33.copyTextureToBuffer({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 33008 */ |
| offset: 33008, |
| buffer: buffer0, |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 192 */ |
| {offset: 188}, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroupLayout7 = pipeline8.getBindGroupLayout(3); |
| let commandEncoder35 = device0.createCommandEncoder({label: '\u5c61\u00f7\u299c'}); |
| let querySet8 = device0.createQuerySet({label: '\u06b9\u06a6\u0ca7\u043a\ub7e3\u1333\u2db6\u8612', type: 'occlusion', count: 1194}); |
| let renderBundle20 = renderBundleEncoder13.finish({label: '\u082b\uc9af\u{1ff50}\ubcd8'}); |
| let externalTexture17 = device0.importExternalTexture({label: '\u{1fcdf}\ua3bb\u0945\u083e\u04ab\u7458', source: video2}); |
| try { |
| renderBundleEncoder5.draw(360083602, 723831763, 63508829, 704906415); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline8); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| let querySet9 = device0.createQuerySet({label: '\uac5a\u0f61\u344e\u{1fac4}', type: 'occlusion', count: 679}); |
| let textureView42 = texture38.createView({label: '\ue968\u059b\u{1fdbd}\ufc9f\u05b6\u5a61\u166e', dimension: '2d-array', baseMipLevel: 3}); |
| let renderBundle21 = renderBundleEncoder6.finish({}); |
| try { |
| renderBundleEncoder5.setBindGroup(5, bindGroup6, new Uint32Array(511), 354, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 59788); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 32512); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 460 widthInBlocks: 115 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3648 */ |
| offset: 3648, |
| buffer: buffer1, |
| }, {width: 115, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder32.clearBuffer(buffer7, 2164, 2380); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 25, y: 59 }, |
| flipY: false, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline39 = await device0.createRenderPipelineAsync({ |
| label: '\uc231\u4cb3\u01f9\u5082\u044b', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint'}, {format: 'r16uint'}, {format: 'r32sint', writeMask: 0}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 17668, |
| attributes: [ |
| {format: 'float32x2', offset: 4280, shaderLocation: 18}, |
| {format: 'snorm16x2', offset: 7160, shaderLocation: 6}, |
| {format: 'sint32x2', offset: 16088, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| await promise7; |
| } catch {} |
| gc(); |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 1869}); |
| let texture40 = device0.createTexture({ |
| label: '\u5e80\u0fda', |
| size: [22, 12, 156], |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm'], |
| }); |
| let textureView43 = texture17.createView({ |
| label: '\ubd92\u2fb7\u8748\u4d86\ud7b9\u195e\u0c12\u{1fd7f}\u0e68\u0b93', |
| dimension: '2d-array', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| baseArrayLayer: 0, |
| }); |
| let sampler15 = device0.createSampler({ |
| label: '\ud430\ud129\u09a8\u0e7b', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 48.16, |
| maxAnisotropy: 20, |
| }); |
| try { |
| commandEncoder33.copyBufferToBuffer(buffer4, 197716, buffer7, 532, 1848); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| commandEncoder35.clearBuffer(buffer7, 5500, 284); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| computePassEncoder5.pushDebugGroup('\u9e35'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 16, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let textureView44 = texture33.createView({ |
| label: '\u{1fb15}\ue07c\ue2d8\u{1f994}\u07bd', |
| mipLevelCount: 3, |
| baseArrayLayer: 722, |
| arrayLayerCount: 6, |
| }); |
| try { |
| renderBundleEncoder5.draw(296615396, 91175828); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 19120); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 34580); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(9, buffer3, 4168); |
| } catch {} |
| try { |
| commandEncoder17.clearBuffer(buffer0, 453452, 39628); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 236280, new Int16Array(18823), 499, 7052); |
| } catch {} |
| let texture41 = device0.createTexture({ |
| size: [600, 96, 251], |
| mipLevelCount: 10, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(4, bindGroup6, new Uint32Array(9072), 2890, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(752817194, 168501952, 957270821, 256090068); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 564, new BigUint64Array(64391), 8239, 84); |
| } catch {} |
| let pipeline40 = await device0.createRenderPipelineAsync({ |
| label: '\u{1f8e5}\u5e23\ub46e\u7058\u9c43\ue29d\ud1c6\ub981\u1a9d\u{1f80c}', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0x98156e8d}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL}, {format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 2404, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 1104, shaderLocation: 1}, |
| {format: 'float32x4', offset: 44, shaderLocation: 3}, |
| {format: 'float32x4', offset: 540, shaderLocation: 12}, |
| {format: 'float32x2', offset: 436, shaderLocation: 20}, |
| ], |
| }, |
| { |
| arrayStride: 17456, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x2', offset: 764, shaderLocation: 13}, |
| {format: 'unorm8x4', offset: 1136, shaderLocation: 9}, |
| {format: 'uint8x4', offset: 2044, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 9756, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 1256, shaderLocation: 2}, |
| {format: 'uint32x2', offset: 428, shaderLocation: 8}, |
| {format: 'uint32x2', offset: 4536, shaderLocation: 15}, |
| {format: 'float32', offset: 2484, shaderLocation: 18}, |
| ], |
| }, |
| { |
| arrayStride: 3336, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x4', offset: 256, shaderLocation: 22}, |
| {format: 'float16x2', offset: 244, shaderLocation: 5}, |
| {format: 'uint32x2', offset: 1244, shaderLocation: 4}, |
| {format: 'uint8x4', offset: 68, shaderLocation: 19}, |
| {format: 'unorm8x4', offset: 1344, shaderLocation: 11}, |
| {format: 'uint32x2', offset: 384, shaderLocation: 16}, |
| {format: 'float32x3', offset: 720, shaderLocation: 23}, |
| ], |
| }, |
| { |
| arrayStride: 848, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32x2', offset: 520, shaderLocation: 14}], |
| }, |
| {arrayStride: 56, attributes: []}, |
| {arrayStride: 4012, attributes: []}, |
| {arrayStride: 23392, attributes: []}, |
| {arrayStride: 7344, stepMode: 'instance', attributes: []}, |
| {arrayStride: 17416, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 5520, |
| stepMode: 'vertex', |
| attributes: [{format: 'float16x4', offset: 1464, shaderLocation: 21}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let imageData5 = new ImageData(180, 192); |
| let pipelineLayout5 = device0.createPipelineLayout({label: '\ue2af\ua121\u5e14\u0bf6\u{1fc2d}\u05d1\u29bc', bindGroupLayouts: []}); |
| let commandEncoder36 = device0.createCommandEncoder({label: '\u0196\u1251\uddca\u730e\u{1fb8c}\u0186\u0fa5'}); |
| let texture42 = device0.createTexture({ |
| label: '\u{1fba9}\ud027\ud201\u8232\u6d98', |
| size: {width: 44, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView45 = texture13.createView({ |
| label: '\u0994\u51ea\u848d\u0950\u06a3\u9ca8\u0c1b\u9bcd\u00a3\ucb1a\uf125', |
| format: 'astc-5x4-unorm', |
| baseMipLevel: 5, |
| baseArrayLayer: 62, |
| arrayLayerCount: 4, |
| }); |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.50, |
| maxAnisotropy: 14, |
| }); |
| try { |
| renderBundleEncoder12.setVertexBuffer(3, buffer3, 14172, 21190); |
| } catch {} |
| try { |
| await buffer6.mapAsync(GPUMapMode.WRITE, 0, 94036); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToBuffer(buffer8, 8300, buffer0, 382708, 83596); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 140972, new Float32Array(25452), 12980, 900); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new BigInt64Array(arrayBuffer0), /* required buffer size: 986 */ |
| {offset: 870, bytesPerRow: 232, rowsPerImage: 157}, {width: 58, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline41 = await device0.createComputePipelineAsync({ |
| label: '\u{1fe36}\u9599\u70c2\u00b5\u2044\u7f29\u0fd7\u0fd6\u21e3\u{1f61c}\u0032', |
| layout: pipelineLayout3, |
| compute: {module: shaderModule3, entryPoint: 'compute0'}, |
| }); |
| let pipeline42 = device0.createRenderPipeline({ |
| label: '\u942a\u5631\u43aa\u0751', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0x2552d05f}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16sint'}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb', writeMask: 0}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'equal', |
| stencilFront: {compare: 'greater', failOp: 'increment-wrap', depthFailOp: 'decrement-clamp', passOp: 'replace'}, |
| stencilBack: {compare: 'greater', failOp: 'replace', depthFailOp: 'replace', passOp: 'decrement-clamp'}, |
| stencilReadMask: 934601132, |
| depthBias: 762125001, |
| depthBiasSlopeScale: 96.47450005793019, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 37404, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 6912, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 1360, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 136, shaderLocation: 10}, |
| {format: 'float32x3', offset: 4412, shaderLocation: 20}, |
| {format: 'uint8x2', offset: 15702, shaderLocation: 15}, |
| {format: 'snorm8x2', offset: 14582, shaderLocation: 1}, |
| {format: 'float32x3', offset: 10756, shaderLocation: 3}, |
| {format: 'float32x4', offset: 1356, shaderLocation: 18}, |
| {format: 'uint32x3', offset: 6600, shaderLocation: 8}, |
| {format: 'unorm10-10-10-2', offset: 21716, shaderLocation: 9}, |
| {format: 'uint32', offset: 13984, shaderLocation: 2}, |
| {format: 'snorm16x2', offset: 3012, shaderLocation: 5}, |
| {format: 'uint32x2', offset: 9552, shaderLocation: 19}, |
| {format: 'uint8x2', offset: 4146, shaderLocation: 4}, |
| {format: 'float16x2', offset: 2164, shaderLocation: 13}, |
| {format: 'float32x3', offset: 584, shaderLocation: 23}, |
| {format: 'float16x4', offset: 3440, shaderLocation: 21}, |
| ], |
| }, |
| { |
| arrayStride: 1348, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 184, shaderLocation: 14}, |
| {format: 'float32', offset: 876, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 392, shaderLocation: 16}, |
| ], |
| }, |
| {arrayStride: 21648, stepMode: 'vertex', attributes: []}, |
| {arrayStride: 24500, attributes: [{format: 'snorm16x4', offset: 4732, shaderLocation: 22}]}, |
| ], |
| }, |
| }); |
| document.body.prepend(video5); |
| gc(); |
| let img3 = await imageWithData(170, 11, '#3ed97a18', '#e87c95e3'); |
| let bindGroup8 = device0.createBindGroup({label: '\uab8a\u{1ff35}\u{1fe6d}\ua6ad\ud975', layout: bindGroupLayout6, entries: []}); |
| let texture43 = device0.createTexture({ |
| size: {width: 1200}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'], |
| }); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({ |
| label: '\ue09b\u0312\u33a7\u6377\u{1ffc6}\u1738', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder18.setBindGroup(5, bindGroup7, new Uint32Array(9789), 534, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(922118967, 1224538684, 1104151128); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 22136); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer8, 'uint16', 126370); |
| } catch {} |
| try { |
| commandEncoder27.clearBuffer(buffer1, 58720, 129680); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 65504, new Float32Array(48445), 27419, 5380); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer9 = device0.createBuffer({ |
| label: '\u0a55\u0a6e\uc19c\ubef0\u6fbe\u3bf4\u{1fe56}', |
| size: 79040, |
| usage: GPUBufferUsage.MAP_READ, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder37 = device0.createCommandEncoder(); |
| let commandBuffer13 = commandEncoder32.finish({label: '\uf29e\u934c\u{1faf4}\u2d5a\u{1fcbd}\u0acd\u087e\u{1fb0e}'}); |
| let computePassEncoder19 = commandEncoder17.beginComputePass({label: '\u8700\ub99d\ue381\u0a35\u055f'}); |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 103324); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline18); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 6328 */ |
| offset: 6328, |
| buffer: buffer3, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder33.copyTextureToTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder38 = device0.createCommandEncoder({label: '\u{1ff6a}\uf379\u5fa9\u0bbb\u8b2c\uf027\u0296\u0c54'}); |
| let textureView46 = texture29.createView({label: '\u0dbe\u{1fcc6}\u0339\u1e4f\uae70\u0fa7\u8f7e\u0cc1', dimension: '2d'}); |
| try { |
| computePassEncoder5.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(1224344598); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 74712); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 39, y: 223 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let commandEncoder39 = device0.createCommandEncoder({label: '\u36bc\u{1fd10}\u{1f72b}\u4311\u{1fec6}'}); |
| let querySet11 = device0.createQuerySet({type: 'occlusion', count: 2267}); |
| let textureView47 = texture16.createView({label: '\u{1f615}\u{1f8b0}\u8b8a\u01ca\u057b'}); |
| let renderBundle22 = renderBundleEncoder4.finish({}); |
| try { |
| renderBundleEncoder3.setBindGroup(4, bindGroup5, new Uint32Array(6277), 2116, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 150296); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 60088); |
| } catch {} |
| try { |
| commandEncoder35.copyTextureToBuffer({ |
| texture: texture17, |
| mipLevel: 1, |
| origin: {x: 2, y: 8, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 204 widthInBlocks: 51 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2400 */ |
| offset: 2400, |
| bytesPerRow: 256, |
| buffer: buffer7, |
| }, {width: 51, height: 23, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| commandEncoder31.clearBuffer(buffer0, 168848, 38740); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let pipeline43 = device0.createRenderPipeline({ |
| label: '\u0a8f\uefb8\u7044\ue88a\uec30\u963c\u04d8\ucbc8\u0fa7\ue053\u01b6', |
| layout: 'auto', |
| multisample: {count: 4, mask: 0xfa5bbaa2}, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.BLUE}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: 0}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilFront: {failOp: 'increment-wrap', depthFailOp: 'increment-clamp'}, |
| stencilBack: {compare: 'never', failOp: 'decrement-wrap', depthFailOp: 'decrement-clamp', passOp: 'increment-wrap'}, |
| stencilReadMask: 2158738466, |
| depthBias: -1831291223, |
| depthBiasSlopeScale: 66.90048783513345, |
| depthBiasClamp: 481.7727038017366, |
| }, |
| vertex: { |
| module: shaderModule5, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 9056, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x4', offset: 48, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 968, shaderLocation: 1}, |
| {format: 'uint32x3', offset: 1456, shaderLocation: 0}, |
| {format: 'uint16x2', offset: 1488, shaderLocation: 13}, |
| {format: 'float32x3', offset: 528, shaderLocation: 18}, |
| {format: 'sint8x4', offset: 4180, shaderLocation: 16}, |
| {format: 'sint8x2', offset: 618, shaderLocation: 2}, |
| {format: 'sint32x2', offset: 3364, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 980, shaderLocation: 23}, |
| {format: 'sint32x3', offset: 688, shaderLocation: 20}, |
| {format: 'unorm16x2', offset: 3336, shaderLocation: 21}, |
| {format: 'uint32x2', offset: 5832, shaderLocation: 19}, |
| {format: 'float32x4', offset: 7444, shaderLocation: 12}, |
| ], |
| }, |
| {arrayStride: 20116, attributes: [{format: 'uint8x4', offset: 436, shaderLocation: 7}]}, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let textureView48 = texture26.createView({label: '\u0d16\u{1f77e}\u0b10\ueb46\uce93', aspect: 'all'}); |
| try { |
| computePassEncoder5.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 37556); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(7, buffer8, 0, 152208); |
| } catch {} |
| try { |
| commandEncoder37.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 992 */ |
| offset: 992, |
| buffer: buffer5, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 136}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 21, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 36, y: 2, z: 31}, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer1), /* required buffer size: 580013 */ |
| {offset: 255, bytesPerRow: 464, rowsPerImage: 294}, {width: 111, height: 74, depthOrArrayLayers: 5}); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let bindGroupLayout8 = device0.createBindGroupLayout({ |
| label: '\u97b3\ud50a\u30e6', |
| entries: [ |
| {binding: 3513, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| { |
| binding: 3816, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4504, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let texture44 = device0.createTexture({ |
| label: '\u{1fd1a}\u531f\u46e2', |
| size: {width: 320, height: 40, depthOrArrayLayers: 9}, |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder5.drawIndexed(18048131, 609067837); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 345024); |
| } catch {} |
| let arrayBuffer2 = buffer6.getMappedRange(0, 48472); |
| let promise12 = buffer0.mapAsync(GPUMapMode.READ, 0, 364900); |
| try { |
| commandEncoder34.copyBufferToBuffer(buffer2, 467876, buffer0, 49792, 66212); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 125372, new BigUint64Array(52710), 33141, 8152); |
| } catch {} |
| let bindGroupLayout9 = device0.createBindGroupLayout({label: '\u006c\u{1ff28}\u{1ffdd}\u094c\ube4f\uac4c', entries: []}); |
| let querySet12 = device0.createQuerySet({label: '\u{1ff4b}\u9206\u{1f6c3}', type: 'occlusion', count: 3904}); |
| try { |
| await promise12; |
| } catch {} |
| let video6 = await videoWithData(); |
| let bindGroupLayout10 = device0.createBindGroupLayout({ |
| label: '\u06ab\u{1fa7a}\u8f91\u00ef', |
| entries: [ |
| {binding: 3794, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 3065, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 3245, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let bindGroup9 = device0.createBindGroup({layout: bindGroupLayout6, entries: []}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({ |
| label: '\u05c7\u4a1c\uacd0\ue078\u0c40', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(6, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 42896); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline27); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 37, y: 48, z: 43}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 274, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 39, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 918 */ |
| {offset: 918}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 26, y: 8 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let img4 = await imageWithData(176, 95, '#eed2d5fe', '#430e4101'); |
| let commandEncoder40 = device0.createCommandEncoder({label: '\u9f73\uae33\u85e4\u66ae\u02d5\u{1f6df}\u0925'}); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 91.66, |
| lodMaxClamp: 93.69, |
| compare: 'greater', |
| }); |
| try { |
| commandEncoder40.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 58788 */ |
| offset: 58788, |
| buffer: buffer5, |
| }, { |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 80684, new BigUint64Array(40920), 38934, 120); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 79, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline44 = await device0.createComputePipelineAsync({ |
| label: '\u7553\u1394\u{1fef0}\ud9f0\u4f3e\u{1f8bb}\u93a7\ubfdc\u02ee\u6eea\u{1fd32}', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule5, entryPoint: 'compute0'}, |
| }); |
| let imageBitmap0 = await createImageBitmap(canvas0); |
| let bindGroup10 = device0.createBindGroup({label: '\u0a91\u{1fa2a}', layout: bindGroupLayout6, entries: []}); |
| let querySet13 = device0.createQuerySet({label: '\u34cb\u0762', type: 'occlusion', count: 3313}); |
| let texture45 = device0.createTexture({ |
| label: '\u0749\u64ca\u0c67\u05b8', |
| size: {width: 176}, |
| dimension: '1d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let textureView49 = texture43.createView({label: '\uf9f1\u09aa\u{1fde4}\uab53\u6578\u{1f75d}\u0e4f'}); |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMaxClamp: 81.56, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder19.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(6, bindGroup9, new Uint32Array(1959), 1555, 0); |
| } catch {} |
| try { |
| commandEncoder37.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 5, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 31618 */ |
| offset: 31618, |
| buffer: buffer1, |
| }, {width: 27, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| computePassEncoder5.popDebugGroup(); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let buffer10 = device0.createBuffer({ |
| label: '\u{1fda1}\u666d\u{1fb7b}\u0432\u{1f836}\u0ac7\u0788', |
| size: 86007, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder41 = device0.createCommandEncoder({label: '\u2675\uf055\u7054'}); |
| let querySet14 = device0.createQuerySet({label: '\u0d7c\u0d2c\uc35e\u0911', type: 'occlusion', count: 3870}); |
| let commandBuffer14 = commandEncoder21.finish({label: '\u8f64\u60c2\u0de3'}); |
| let externalTexture18 = device0.importExternalTexture({label: '\u5518\u0001', source: video5, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(560637802, 1050161321, 240349602, 609789258); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(806384968, 1167124074); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 161404); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer8, 'uint32', 32652, 22863); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer10, 10708, 21948); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({label: '\u0423\u2581\u0b3b', layout: bindGroupLayout9, entries: []}); |
| let buffer11 = device0.createBuffer({size: 130648, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let renderBundle23 = renderBundleEncoder20.finish({label: '\u{1fc56}\u14ab\u{1fddc}\ua883\uf2b6\u0224\u{1fcd8}\u0913\u{1faa5}\u50d6\u623f'}); |
| let sampler19 = device0.createSampler({ |
| label: '\u0ff0\u019d\u029f', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 60.71, |
| lodMaxClamp: 84.04, |
| }); |
| try { |
| renderBundleEncoder5.drawIndexed(1050774697, 1064584766, 1182291793, 1044040776); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 115492); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline39); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| commandEncoder37.copyBufferToBuffer(buffer6, 100324, buffer0, 356048, 105132); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 0, y: 99 }, |
| flipY: false, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline45 = device0.createRenderPipeline({ |
| label: '\u6f74\u{1fbe0}\u0e04\u{1fde9}\u072b\u0e15\u{1f7f0}\u{1f9e3}\u4ca2', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0x34fa6102}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }, {format: 'rg16sint'}, {format: 'r16uint'}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-src'}, |
| alpha: {operation: 'add', srcFactor: 'constant', dstFactor: 'constant'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilFront: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'invert', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'never', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'decrement-wrap'}, |
| stencilWriteMask: 3725860122, |
| depthBiasSlopeScale: 182.2974757756392, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 3212, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 1976, shaderLocation: 18}, |
| {format: 'sint16x2', offset: 748, shaderLocation: 13}, |
| {format: 'unorm8x2', offset: 420, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 1974}); |
| let texture46 = device0.createTexture({ |
| label: '\u0483\u8a7c', |
| size: [1280, 160, 38], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView50 = texture20.createView({label: '\u{1fd24}\u{1f71a}\ufcf9\u3615'}); |
| let computePassEncoder20 = commandEncoder36.beginComputePass(); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let externalTexture19 = device0.importExternalTexture({ |
| label: '\u0583\u0bb3\u60e0\u{1fc4f}\ub320\u04ca\u03e5\u0874', |
| source: video1, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| renderBundleEncoder5.drawIndexed(586429773, 1138564825); |
| } catch {} |
| let pipeline46 = device0.createComputePipeline({ |
| label: '\u6622\ue6a5\u{1f987}', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline47 = device0.createRenderPipeline({ |
| label: '\u01af\u1a33\u7d55\u{1fb49}', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0xa9ac43b7}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}, {format: 'rg16sint'}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32sint'}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'one-minus-constant'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'always', |
| stencilFront: {compare: 'less', failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'replace'}, |
| stencilBack: {compare: 'never', failOp: 'keep', depthFailOp: 'decrement-clamp', passOp: 'zero'}, |
| stencilReadMask: 2261336113, |
| stencilWriteMask: 1636930340, |
| depthBiasClamp: 744.2829714273001, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 57544, stepMode: 'instance', attributes: []}, |
| {arrayStride: 8392, stepMode: 'instance', attributes: []}, |
| {arrayStride: 0, attributes: []}, |
| {arrayStride: 8244, attributes: []}, |
| { |
| arrayStride: 8536, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x4', offset: 3896, shaderLocation: 6}], |
| }, |
| { |
| arrayStride: 31440, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm16x4', offset: 7924, shaderLocation: 18}, |
| {format: 'sint32x4', offset: 29900, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw'}, |
| }); |
| let commandEncoder43 = device0.createCommandEncoder({label: '\u{1fd5c}\u8a44\u0e83\u{1ffec}\u{1fb66}\u{1fbe1}\u{1f8f2}\u01e0\u0ae0\u{1fd10}'}); |
| let querySet16 = device0.createQuerySet({label: '\u0205\u{1f9da}\u0d3d\u0cdd\u0fc8', type: 'occlusion', count: 2205}); |
| let texture47 = device0.createTexture({ |
| label: '\u00e2\u{1f8df}\u2eb3\u{1fb28}\u25f3\ufb70\u{1f90f}\u4ccf\u3d0e', |
| size: [160, 20, 1], |
| mipLevelCount: 5, |
| format: 'astc-8x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x5-unorm', 'astc-8x5-unorm', 'astc-8x5-unorm'], |
| }); |
| let externalTexture20 = device0.importExternalTexture({ |
| label: '\u674a\u7acb\u57bc\u5987\u{1f6d9}\u01bd\u0ac3\u{1fd4d}\u149f\u2ae1', |
| source: video5, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 9220); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(8, buffer3, 0); |
| } catch {} |
| try { |
| commandEncoder42.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 110416 */ |
| offset: 844, |
| bytesPerRow: 256, |
| rowsPerImage: 107, |
| buffer: buffer5, |
| }, { |
| texture: texture25, |
| mipLevel: 5, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 5}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| computePassEncoder15.pushDebugGroup('\ud2fd'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| gc(); |
| let shaderModule6 = device0.createShaderModule({ |
| label: '\ud639\u0fce', |
| code: `@group(1) @binding(1494) |
| var<storage, read_write> function5: array<u32>; |
| @group(2) @binding(1494) |
| var<storage, read_write> n2: array<u32>; |
| |
| @compute @workgroup_size(6, 3, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S5 { |
| @builtin(sample_mask) f0: u32, |
| @location(9) f1: vec3<i32>, |
| @location(84) f2: f32 |
| } |
| struct FragmentOutput0 { |
| @location(2) f0: vec4<u32>, |
| @location(0) f1: vec4<u32>, |
| @location(4) f2: vec4<f32>, |
| @location(3) f3: vec4<i32>, |
| @location(1) f4: vec4<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(59) a0: i32, @location(7) a1: vec2<u32>, @location(52) a2: vec3<u32>, @location(82) a3: vec4<f32>, @location(53) a4: vec2<u32>, @location(0) a5: vec3<f32>, @location(67) a6: vec4<u32>, @location(36) a7: vec3<f16>, @location(21) a8: vec4<f32>, @location(1) a9: vec4<u32>, @location(13) a10: vec2<u32>, @location(37) a11: f16, a12: S5) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S4 { |
| @location(18) f0: i32, |
| @location(6) f1: vec2<i32>, |
| @location(4) f2: vec4<u32> |
| } |
| struct VertexOutput0 { |
| @location(0) f64: vec3<f32>, |
| @location(53) f65: vec2<u32>, |
| @builtin(position) f66: vec4<f32>, |
| @location(8) f67: u32, |
| @location(21) f68: vec4<f32>, |
| @location(67) f69: vec4<u32>, |
| @location(1) f70: vec4<u32>, |
| @location(9) f71: vec3<i32>, |
| @location(59) f72: i32, |
| @location(84) f73: f32, |
| @location(36) f74: vec3<f16>, |
| @location(52) f75: vec3<u32>, |
| @location(7) f76: vec2<u32>, |
| @location(82) f77: vec4<f32>, |
| @location(13) f78: vec2<u32>, |
| @location(37) f79: f16 |
| } |
| |
| @vertex |
| fn vertex0(a0: S4, @location(13) a1: vec2<u32>, @location(0) a2: f16, @location(22) a3: i32, @location(10) a4: vec3<f32>, @location(17) a5: vec2<f32>, @location(11) a6: f32, @location(3) a7: vec4<f32>, @location(8) a8: vec4<u32>, @location(21) a9: f16, @builtin(vertex_index) a10: u32, @location(5) a11: vec2<f32>, @location(14) a12: vec2<f16>, @location(23) a13: vec4<i32>, @location(12) a14: vec4<u32>, @location(2) a15: vec2<u32>, @location(7) a16: vec2<u32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| let bindGroup12 = device0.createBindGroup({ |
| label: '\u14ed\u0f5d\u8180\u08a5', |
| layout: bindGroupLayout7, |
| entries: [{binding: 1530, resource: externalTexture15}], |
| }); |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({ |
| label: '\u0d9e\u48bb\u68a7\u{1fa6c}\u0650\u30ac\u{1f970}\ude29\u10fa', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup2, new Uint32Array(377), 109, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(4, bindGroup3); |
| } catch {} |
| try { |
| commandEncoder41.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 2, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 15472 */ |
| offset: 15472, |
| rowsPerImage: 82, |
| buffer: buffer10, |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 608, new DataView(new ArrayBuffer(13783)), 10183, 48); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 246 */ |
| {offset: 246, bytesPerRow: 304, rowsPerImage: 108}, {width: 87, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.label = '\u76c1\u03ae\u0752\u{1faf8}\u034e'; |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| label: '\u6daf\uc1a1\u0c9a\u59cc\u9f49\ue734\u0710\ufc68\u{1febe}\u336a\u{1fce4}', |
| code: `@group(1) @binding(1530) |
| var<storage, read_write> local3: array<u32>; |
| @group(0) @binding(1530) |
| var<storage, read_write> function6: array<u32>; |
| @group(2) @binding(1530) |
| var<storage, read_write> global4: array<u32>; |
| @group(3) @binding(1530) |
| var<storage, read_write> global5: array<u32>; |
| |
| @compute @workgroup_size(1, 1, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(0) f0: vec2<u32>, |
| @location(2) f1: vec3<u32>, |
| @location(3) f2: vec4<i32>, |
| @location(4) f3: vec4<f32>, |
| @location(1) f4: vec2<i32>, |
| @location(6) f5: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32, @builtin(sample_mask) a1: u32, @builtin(position) a2: vec4<f32>, @builtin(front_facing) a3: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S6 { |
| @builtin(instance_index) f0: u32 |
| } |
| |
| @vertex |
| fn vertex0(@location(21) a0: vec4<u32>, @location(10) a1: i32, @builtin(vertex_index) a2: u32, @location(0) a3: vec4<u32>, @location(2) a4: vec4<u32>, @location(12) a5: vec4<f16>, @location(9) a6: vec2<u32>, a7: S6, @location(22) a8: i32, @location(3) a9: vec2<f32>, @location(16) a10: f32, @location(7) a11: u32, @location(14) a12: vec3<i32>, @location(18) a13: vec4<u32>, @location(1) a14: vec3<i32>, @location(6) a15: vec2<f16>, @location(5) a16: vec4<u32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let pipelineLayout6 = device0.createPipelineLayout({label: '\u716d\uadc9\u1a90\u{1f770}\u0b2b\u3304', bindGroupLayouts: []}); |
| let buffer12 = device0.createBuffer({ |
| label: '\uad97\u0852\u46a7\u758b\u0a88\u{1f870}', |
| size: 152317, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| let commandEncoder45 = device0.createCommandEncoder(); |
| let commandBuffer15 = commandEncoder16.finish({label: '\ue3eb\u{1fd43}\u72b1\uee63\u0035\ua347\u9b5d\u{1f882}\u{1f983}'}); |
| try { |
| renderBundleEncoder5.draw(882276210, 1076417888); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer8, 'uint16', 140712, 710); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder39.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 19378 */ |
| offset: 19362, |
| rowsPerImage: 268, |
| buffer: buffer10, |
| }, {width: 8, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder13.copyTextureToTexture({ |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 220, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 24, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder37.resolveQuerySet(querySet13, 218, 1222, buffer10, 60416); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 8, y: 96 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise15 = device0.createComputePipelineAsync({ |
| label: '\u8d17\u4666\u713e\u1c61\u0c80', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule7, entryPoint: 'compute0', constants: {}}, |
| }); |
| gc(); |
| let offscreenCanvas7 = new OffscreenCanvas(938, 805); |
| let pipelineLayout7 = device0.createPipelineLayout({ |
| label: '\u0bfe\u0d0f\u{1fe1a}\u0fe5\u{1fb24}', |
| bindGroupLayouts: [bindGroupLayout8, bindGroupLayout2], |
| }); |
| let commandEncoder46 = device0.createCommandEncoder(); |
| let textureView51 = texture19.createView({aspect: 'all'}); |
| let computePassEncoder21 = commandEncoder40.beginComputePass({}); |
| try { |
| renderBundleEncoder5.drawIndexed(260665632); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 68804); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToBuffer(buffer4, 198376, buffer0, 20324, 47632); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture44, |
| mipLevel: 1, |
| origin: {x: 5, y: 4, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer2), /* required buffer size: 2915 */ |
| {offset: 661, bytesPerRow: 230, rowsPerImage: 108}, {width: 92, height: 10, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 81, y: 9 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(video1); |
| let querySet17 = device0.createQuerySet({type: 'occlusion', count: 898}); |
| let textureView52 = texture5.createView({label: '\u0e63\u1b14'}); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({ |
| label: '\ub1a9\u{1fd22}\u{1fa9b}\u{1f6ca}\u4735\u{1fac2}\ue1a7', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: true, |
| }); |
| let renderBundle24 = renderBundleEncoder18.finish({label: '\u86c5\u{1fd88}\u7b7c\u0d5d\ufb1e'}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(25913768, 1142600488, 627106518, -273832594, 1228253612); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer11, 28800); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(5, buffer3, 24180, 2902); |
| } catch {} |
| try { |
| commandEncoder37.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder15.popDebugGroup(); |
| } catch {} |
| try { |
| commandEncoder33.insertDebugMarker('\u{1f6a0}'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 209, y: 2, z: 31}, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer0), /* required buffer size: 1217939 */ |
| {offset: 843, bytesPerRow: 376, rowsPerImage: 228}, {width: 90, height: 45, depthOrArrayLayers: 15}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 204, y: 31 }, |
| flipY: true, |
| }, { |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas8 = new OffscreenCanvas(101, 439); |
| let video7 = await videoWithData(); |
| let textureView53 = texture1.createView({ |
| label: '\uf274\u1bcf\u508b\u67b4\u0e56\u9576\u10e8\u0998\uc19a\u639b\u{1febf}', |
| baseMipLevel: 0, |
| baseArrayLayer: 0, |
| }); |
| let sampler20 = device0.createSampler({ |
| label: '\u50b4\u7208', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 10.54, |
| lodMaxClamp: 56.40, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderBundleEncoder8.setBindGroup(4, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(140036734); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(3, buffer3, 13184, 6920); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToTexture({ |
| /* bytesInLastRow: 1988 widthInBlocks: 994 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 70698 */ |
| offset: 70698, |
| bytesPerRow: 2048, |
| buffer: buffer5, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 49, y: 33, z: 0}, |
| aspect: 'all', |
| }, {width: 994, height: 12, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToBuffer({ |
| texture: texture13, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 23}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 268688 */ |
| offset: 28048, |
| bytesPerRow: 256, |
| rowsPerImage: 235, |
| buffer: buffer1, |
| }, {width: 5, height: 0, depthOrArrayLayers: 5}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder14.insertDebugMarker('\u916a'); |
| } catch {} |
| let pipeline48 = device0.createRenderPipeline({ |
| label: '\ua07b\u08dc\u{1fbd2}\u0538\u0105\ubb53\u1092\u0ebf\u{1fcdc}', |
| layout: pipelineLayout3, |
| multisample: {mask: 0x83cd16e}, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: 0}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'equal', |
| stencilFront: {compare: 'always', depthFailOp: 'invert', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'increment-clamp', passOp: 'decrement-clamp'}, |
| stencilReadMask: 2576342120, |
| stencilWriteMask: 615273121, |
| depthBias: 1372866703, |
| depthBiasSlopeScale: 197.69497796302556, |
| depthBiasClamp: 945.2748890481064, |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 24468, |
| attributes: [ |
| {format: 'sint32x4', offset: 5920, shaderLocation: 22}, |
| {format: 'uint8x4', offset: 9560, shaderLocation: 16}, |
| {format: 'uint32x3', offset: 16036, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 524, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 120, shaderLocation: 6}, |
| {format: 'uint32', offset: 104, shaderLocation: 13}, |
| ], |
| }, |
| { |
| arrayStride: 6024, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 860, shaderLocation: 19}, |
| {format: 'uint16x4', offset: 2388, shaderLocation: 5}, |
| {format: 'float16x2', offset: 348, shaderLocation: 23}, |
| {format: 'snorm16x4', offset: 1700, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| gc(); |
| let img5 = await imageWithData(67, 237, '#be5909d7', '#7f11ee79'); |
| let bindGroupLayout11 = device0.createBindGroupLayout({ |
| label: '\ud10f\u4f7b\u{1fc04}\u699d\u09e1\u{1f9f4}\u{1f8ba}', |
| entries: [ |
| { |
| binding: 1344, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 1992, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| ], |
| }); |
| let textureView54 = texture6.createView({label: '\u8cc2\ub4d4', dimension: '2d-array', format: 'bgra8unorm'}); |
| try { |
| renderBundleEncoder22.setBindGroup(4, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(393893659, 258005631, 428146361, 391422160); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(232721611, 921311292); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 6784); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToBuffer(buffer2, 183516, buffer7, 5856, 692); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 1176 widthInBlocks: 588 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 69646 */ |
| offset: 68470, |
| buffer: buffer8, |
| }, { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 452, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 588, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer8); |
| } catch {} |
| try { |
| commandEncoder46.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: {x: 7, y: 5, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 13, y: 8, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 138, height: 9, depthOrArrayLayers: 3}); |
| } catch {} |
| try { |
| computePassEncoder3.pushDebugGroup('\u090a'); |
| } catch {} |
| document.body.prepend(video0); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({ |
| label: '\u{1fa59}\u{1ff1c}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: true, |
| }); |
| let externalTexture21 = device0.importExternalTexture({label: '\u8f46\u0f56', source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder5.draw(196447438, 417413844); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 71988); |
| } catch {} |
| try { |
| commandEncoder34.clearBuffer(buffer1, 100056, 253780); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| computePassEncoder3.popDebugGroup(); |
| } catch {} |
| try { |
| renderBundleEncoder17.insertDebugMarker('\u087c'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 58, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Float32Array(arrayBuffer2), /* required buffer size: 367 */ |
| {offset: 367}, {width: 751, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img2, |
| origin: { x: 77, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder47 = device0.createCommandEncoder(); |
| let texture48 = device0.createTexture({ |
| size: {width: 1200, height: 192, depthOrArrayLayers: 1}, |
| mipLevelCount: 9, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let textureView55 = texture33.createView({baseMipLevel: 4, mipLevelCount: 1, baseArrayLayer: 958, arrayLayerCount: 93}); |
| let renderBundle25 = renderBundleEncoder4.finish({label: '\u0706\u0d34\u6b82\u0e82\ubfca\u0c3d'}); |
| try { |
| renderBundleEncoder5.draw(932230315, 640730782, 503482169, 904243049); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 26668); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(arrayBuffer1), /* required buffer size: 473 */ |
| {offset: 473, bytesPerRow: 273}, {width: 8, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder48 = device0.createCommandEncoder({label: '\u0e2c\u50e0\uf1d5\ud8cb\u{1fe17}\u936c'}); |
| let textureView56 = texture47.createView({ |
| label: '\ua7a7\uc4c8\u0082\u30f8\u3a46\u0b6e\u{1ff63}\u084e\u01a9\u{1f90e}', |
| dimension: '2d-array', |
| format: 'astc-8x5-unorm', |
| baseMipLevel: 3, |
| }); |
| let computePassEncoder22 = commandEncoder45.beginComputePass({label: '\u0b3b\ubbe2\u944d\u896f\u0a52\u{1fd83}'}); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup4, new Uint32Array(1317), 835, 0); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline44); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(240, undefined); |
| } catch {} |
| try { |
| commandEncoder48.clearBuffer(buffer7, 6136, 348); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer0), /* required buffer size: 456 */ |
| {offset: 456}, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3485, |
| visibility: 0, |
| texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView57 = texture39.createView({label: '\u8fc5\uc71e\u02c6\u0e05'}); |
| let renderBundle26 = renderBundleEncoder24.finish({label: '\u{1fb6a}\u0070\u026e\u82a6'}); |
| let sampler21 = device0.createSampler({ |
| label: '\u0c97\u015e\u{1fbdf}\u0c36', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 7.142, |
| lodMaxClamp: 98.86, |
| }); |
| try { |
| renderBundleEncoder5.drawIndexed(255507413, 452245493, 142224177, -642748429, 634157070); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline39); |
| } catch {} |
| let arrayBuffer3 = buffer6.getMappedRange(48472, 9388); |
| try { |
| await buffer7.mapAsync(GPUMapMode.READ, 0, 2104); |
| } catch {} |
| try { |
| commandEncoder42.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 16568 */ |
| offset: 16568, |
| bytesPerRow: 0, |
| buffer: buffer4, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| try { |
| commandEncoder37.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder43.clearBuffer(buffer7, 5052, 1288); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img5, |
| origin: { x: 38, y: 79 }, |
| flipY: false, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer16 = commandEncoder42.finish(); |
| let textureView58 = texture2.createView({label: '\u05af\udb78\u07da\u1b70\u31a5\u0258', baseMipLevel: 1}); |
| try { |
| renderBundleEncoder12.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 9726 */ |
| offset: 9726, |
| buffer: buffer10, |
| }, {width: 11, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder13.resolveQuerySet(querySet1, 1645, 595, buffer10, 75520); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer0), /* required buffer size: 474 */ |
| {offset: 366, bytesPerRow: 327}, {width: 54, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 94, y: 35 }, |
| flipY: true, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) }; |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let img6 = await imageWithData(255, 201, '#80bed013', '#f9ea0ca6'); |
| let commandEncoder49 = device0.createCommandEncoder({label: '\u1cb9\u89d3\u{1fc9b}\ue988\uf3d2\u{1f814}\uc260\u3764\u1c11\u{1f6df}\u46b0'}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| commandEncoder43.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 153, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 130, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12, commandBuffer16, commandBuffer15]); |
| } catch {} |
| let externalTexture22 = device0.importExternalTexture({ |
| label: '\u089e\u07e8\u{1fdd5}\u0ab3\u{1fae5}\u8093\u12f5\u{1fb89}', |
| source: video1, |
| colorSpace: 'srgb', |
| }); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(306789891, 30665638, 840491106, 646695226); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 29608); |
| } catch {} |
| let promise16 = buffer4.mapAsync(GPUMapMode.WRITE, 0, 138712); |
| try { |
| commandEncoder47.copyTextureToTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 361, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 176, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline49 = device0.createComputePipeline({ |
| label: '\ub35a\u852f\u449c\u045a\u5bdf\u92d9', |
| layout: 'auto', |
| compute: {module: shaderModule2, entryPoint: 'compute0'}, |
| }); |
| try { |
| offscreenCanvas8.getContext('webgl'); |
| } catch {} |
| let texture49 = device0.createTexture({ |
| label: '\u075b\u{1f7a4}\u1ddb\u0b2c\u{1f62e}', |
| size: {width: 1194, height: 64, depthOrArrayLayers: 1}, |
| mipLevelCount: 11, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float'], |
| }); |
| let computePassEncoder23 = commandEncoder35.beginComputePass({label: '\u0a35\u58dd\u29e3\u02c4\u0139'}); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup10, new Uint32Array(494), 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(558661977); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer11, 12124); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(0, buffer8, 37988, 106091); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 390 widthInBlocks: 195 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 17698 */ |
| offset: 17698, |
| rowsPerImage: 220, |
| buffer: buffer5, |
| }, { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 89, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 195, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 209, y: 21, z: 7}, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 281099 */ |
| {offset: 103, bytesPerRow: 344, rowsPerImage: 257}, {width: 73, height: 46, depthOrArrayLayers: 4}); |
| } catch {} |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({ |
| label: '\u{1f863}\u6640', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder19.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 130632); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer11, 'uint16', 35682, 10337); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline39); |
| } catch {} |
| try { |
| commandEncoder4.copyBufferToBuffer(buffer12, 72820, buffer7, 6244, 228); |
| dissociateBuffer(device0, buffer12); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| commandEncoder41.copyTextureToBuffer({ |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 123, y: 7, z: 8}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4336 widthInBlocks: 1084 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 16072 */ |
| offset: 16072, |
| bytesPerRow: 4352, |
| buffer: buffer10, |
| }, {width: 1084, height: 81, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToTexture({ |
| texture: texture2, |
| mipLevel: 3, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 1, |
| origin: {x: 183, y: 31, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder37.clearBuffer(buffer1, 106084, 104576); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| let img7 = await imageWithData(255, 240, '#45c3284e', '#9d2b6e6c'); |
| let commandEncoder50 = device0.createCommandEncoder(); |
| let querySet18 = device0.createQuerySet({ |
| label: '\u03d0\u3ef4\ud786\u0a67\u0430\u0920\u9ba6\u4962\u06c6\u0c17\u{1f842}', |
| type: 'occlusion', |
| count: 1483, |
| }); |
| try { |
| renderBundleEncoder5.draw(9344457); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(290887137, 72217639); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 111976); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(10, buffer3, 3068, 27189); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 992 */ |
| offset: 992, |
| buffer: buffer10, |
| }, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| let pipeline50 = device0.createComputePipeline({ |
| label: '\uf2af\u08ea\u012f\u{1f733}\u6f5a\u{1f674}\u26bb\u{1f9e5}\u0bf7\u6d9e\u{1fdb5}', |
| layout: pipelineLayout3, |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline51 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule7, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'r32sint'}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater-equal', |
| stencilFront: {compare: 'greater', failOp: 'zero', depthFailOp: 'zero', passOp: 'decrement-wrap'}, |
| stencilBack: {compare: 'less', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'increment-clamp'}, |
| stencilReadMask: 47317071, |
| stencilWriteMask: 1407286387, |
| depthBias: 0, |
| depthBiasSlopeScale: 526.2779157707347, |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 32764, |
| attributes: [ |
| {format: 'uint32x3', offset: 1520, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 6410, shaderLocation: 3}, |
| {format: 'uint16x4', offset: 19792, shaderLocation: 21}, |
| {format: 'uint32x3', offset: 6732, shaderLocation: 18}, |
| {format: 'uint8x4', offset: 9496, shaderLocation: 5}, |
| {format: 'sint8x2', offset: 32762, shaderLocation: 22}, |
| ], |
| }, |
| {arrayStride: 4516, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 34600, |
| attributes: [ |
| {format: 'unorm8x2', offset: 13934, shaderLocation: 16}, |
| {format: 'sint16x4', offset: 5764, shaderLocation: 10}, |
| {format: 'float16x4', offset: 9928, shaderLocation: 6}, |
| {format: 'sint32', offset: 6444, shaderLocation: 1}, |
| {format: 'float16x4', offset: 11664, shaderLocation: 12}, |
| ], |
| }, |
| {arrayStride: 6392, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 7744, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x2', offset: 540, shaderLocation: 14}, |
| {format: 'uint32x2', offset: 784, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 16748, |
| stepMode: 'instance', |
| attributes: [{format: 'uint16x2', offset: 836, shaderLocation: 0}], |
| }, |
| { |
| arrayStride: 14048, |
| stepMode: 'instance', |
| attributes: [{format: 'uint8x4', offset: 2740, shaderLocation: 2}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-list', frontFace: 'ccw', unclippedDepth: true}, |
| }); |
| let bindGroupLayout13 = pipeline47.getBindGroupLayout(1); |
| let bindGroup13 = device0.createBindGroup({ |
| label: '\u8e8b\u0fc1\ucd8c\u{1fa98}\uef06\ufa96\u0509\u{1fce4}', |
| layout: bindGroupLayout7, |
| entries: [{binding: 1530, resource: externalTexture10}], |
| }); |
| let textureView59 = texture16.createView({label: '\u{1fd5c}\u489e\u{1fc8d}\u01b8\u09a3\u02bd\u{1ff87}\u{1feb2}\uaf37'}); |
| let sampler22 = device0.createSampler({ |
| label: '\u0801\u3d16\u095f\u3fe7\u6093', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 55.59, |
| lodMaxClamp: 99.09, |
| }); |
| try { |
| renderBundleEncoder21.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer2, 133320, buffer0, 99168, 239772); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder4.copyTextureToTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 48, y: 15, z: 35}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView60 = texture15.createView({label: '\u1721\ub408\u{1fec9}\ubd2f\u03fb', baseArrayLayer: 0}); |
| let renderBundle27 = renderBundleEncoder7.finish({}); |
| let sampler23 = device0.createSampler({ |
| label: '\u{1ff79}\u708f\u0b08', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 4.932, |
| lodMaxClamp: 47.22, |
| }); |
| let externalTexture23 = device0.importExternalTexture({label: '\u3bee\u022d\u17c1\u04a7\u{1fea6}\u0077\u0773\u{1f85b}', source: video7, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder5.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(711532884, 914247374, 247616357, 56273324); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 9376 */ |
| offset: 9376, |
| buffer: buffer5, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| let commandEncoder51 = device0.createCommandEncoder({label: '\u{1ffbf}\u{1fff9}'}); |
| let commandBuffer17 = commandEncoder49.finish(); |
| let textureView61 = texture27.createView({label: '\u0cb1\u4caf\u035a', dimension: '2d', aspect: 'all', baseArrayLayer: 72}); |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| commandEncoder37.copyTextureToBuffer({ |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 61, y: 2, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 524 widthInBlocks: 131 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 8736 */ |
| offset: 8736, |
| bytesPerRow: 768, |
| buffer: buffer1, |
| }, {width: 131, height: 2, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 21644, new Float32Array(17816), 492, 148); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 36, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint16Array(arrayBuffer1), /* required buffer size: 164 */ |
| {offset: 164, bytesPerRow: 193}, {width: 21, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame3 = new VideoFrame(offscreenCanvas6, {timestamp: 0}); |
| let texture50 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 2668); |
| } catch {} |
| try { |
| commandEncoder33.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 162976 */ |
| offset: 100000, |
| bytesPerRow: 256, |
| rowsPerImage: 123, |
| buffer: buffer8, |
| }, { |
| texture: texture41, |
| mipLevel: 6, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 3}); |
| dissociateBuffer(device0, buffer8); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToBuffer({ |
| texture: texture17, |
| mipLevel: 1, |
| origin: {x: 2, y: 17, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 284 widthInBlocks: 71 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 18540 */ |
| offset: 5968, |
| bytesPerRow: 768, |
| rowsPerImage: 254, |
| buffer: buffer1, |
| }, {width: 71, height: 17, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder41.copyTextureToTexture({ |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 92, y: 9, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 36, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder4.resolveQuerySet(querySet4, 3121, 243, buffer10, 59392); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let textureView62 = texture42.createView({label: '\u1942\u{1fe1c}\u{1f8dc}', aspect: 'all', baseMipLevel: 2}); |
| try { |
| renderBundleEncoder5.drawIndexed(924571669); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 6368); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 80476); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(9, buffer8); |
| } catch {} |
| try { |
| commandEncoder47.clearBuffer(buffer1, 282716, 7888); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| let pipeline52 = await device0.createRenderPipelineAsync({ |
| label: '\u8954\u2125\u{1fa56}\u71b8\u{1f843}\u0da6', |
| layout: pipelineLayout5, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater-equal', |
| stencilFront: {compare: 'less', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'zero'}, |
| stencilBack: {compare: 'greater', failOp: 'zero', passOp: 'replace'}, |
| stencilReadMask: 1835944646, |
| stencilWriteMask: 3232146003, |
| depthBias: 2085529829, |
| depthBiasSlopeScale: 482.9006492328899, |
| depthBiasClamp: 664.1888196463711, |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 41412, |
| attributes: [ |
| {format: 'float32x2', offset: 20632, shaderLocation: 12}, |
| {format: 'sint32x2', offset: 7692, shaderLocation: 22}, |
| {format: 'snorm8x4', offset: 25644, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 32016, |
| attributes: [ |
| {format: 'uint16x4', offset: 12064, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 4604, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 21708, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x2', offset: 1936, shaderLocation: 16}, |
| {format: 'uint16x4', offset: 3864, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 5424, shaderLocation: 14}, |
| {format: 'sint16x2', offset: 1708, shaderLocation: 10}, |
| {format: 'uint32x2', offset: 72, shaderLocation: 2}, |
| {format: 'uint32x2', offset: 2064, shaderLocation: 0}, |
| {format: 'uint16x2', offset: 10600, shaderLocation: 21}, |
| {format: 'uint32x2', offset: 6116, shaderLocation: 18}, |
| ], |
| }, |
| { |
| arrayStride: 12196, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint8x4', offset: 9800, shaderLocation: 1}, |
| {format: 'float32x4', offset: 348, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| gc(); |
| let commandEncoder52 = device0.createCommandEncoder({label: '\u1c8c\u3b43\u01ef\ue695\u01d1'}); |
| let texture51 = device0.createTexture({ |
| label: '\u7fb1\u259b\ua3e6', |
| size: [600, 96, 1], |
| mipLevelCount: 3, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView63 = texture13.createView({ |
| label: '\u0ec2\u307d\u8afe\u98be\u0766\u7ea6', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| baseArrayLayer: 32, |
| arrayLayerCount: 45, |
| }); |
| let computePassEncoder24 = commandEncoder44.beginComputePass({}); |
| let renderBundle28 = renderBundleEncoder10.finish({label: '\u{1fbd3}\u7a10\u{1fb5f}\uc1c9\uda2c\u8d42\uf555\u4460\u0839'}); |
| let externalTexture24 = device0.importExternalTexture({ |
| label: '\u{1faee}\uf0cf\u040d\u38f9\u8cb3\u2d6f\u{1fcb6}\u0953\u06d7\u0213', |
| source: videoFrame1, |
| colorSpace: 'srgb', |
| }); |
| try { |
| renderBundleEncoder5.draw(31761179); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(66329705, 161594878, 723979714, 948186381, 1018009704); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 376, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture41, |
| mipLevel: 6, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 9, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let offscreenCanvas9 = new OffscreenCanvas(355, 415); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let querySet19 = device0.createQuerySet({label: '\u01ff\u{1fca5}\u746c\u070f', type: 'occlusion', count: 232}); |
| let texture52 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView64 = texture25.createView({ |
| label: '\u{1f75c}\ucb35\u3f12\u42d8\u0343\u{1fe91}', |
| format: 'rg16sint', |
| baseMipLevel: 5, |
| mipLevelCount: 1, |
| }); |
| let renderBundle29 = renderBundleEncoder23.finish({label: '\u4c9b\u098d\u9f36\u68ea\u{1fbce}\u{1fe77}\ubdd5\u{1fc2a}\u955b\u0814\uc4bc'}); |
| try { |
| renderBundleEncoder15.setBindGroup(5, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(558601149, 1073996789, 687115751, 959243896); |
| } catch {} |
| try { |
| commandEncoder41.clearBuffer(buffer0, 410840, 3216); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| let externalTexture25 = device0.importExternalTexture({label: '\u0c8d\u37fb\u{1fa15}\ubd5c', source: video6, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(769508725, 842142325, 107003956, 693128236); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer8, 'uint16', 82258, 64639); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(7, buffer8, 0, 62937); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer6, 222076, buffer10, 19944, 7068); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 55788 */ |
| offset: 55788, |
| buffer: buffer8, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer8); |
| } catch {} |
| try { |
| commandEncoder46.copyTextureToBuffer({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 10656 */ |
| offset: 10604, |
| buffer: buffer10, |
| }, {width: 13, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder4.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 547 */ |
| {offset: 547, rowsPerImage: 25}, {width: 163, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline53 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'src', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater-equal', |
| stencilFront: {compare: 'greater-equal', failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'greater', failOp: 'increment-wrap', depthFailOp: 'increment-clamp', passOp: 'decrement-wrap'}, |
| stencilReadMask: 727197643, |
| stencilWriteMask: 583111330, |
| depthBiasClamp: 988.168367261042, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 556, |
| attributes: [ |
| {format: 'uint16x4', offset: 116, shaderLocation: 2}, |
| {format: 'uint8x2', offset: 48, shaderLocation: 4}, |
| {format: 'uint32x2', offset: 8, shaderLocation: 8}, |
| {format: 'float32', offset: 0, shaderLocation: 21}, |
| {format: 'snorm8x4', offset: 40, shaderLocation: 22}, |
| {format: 'snorm8x2', offset: 18, shaderLocation: 11}, |
| {format: 'float32', offset: 52, shaderLocation: 3}, |
| ], |
| }, |
| { |
| arrayStride: 6532, |
| attributes: [ |
| {format: 'uint8x4', offset: 568, shaderLocation: 10}, |
| {format: 'snorm16x4', offset: 3380, shaderLocation: 12}, |
| {format: 'float16x4', offset: 5544, shaderLocation: 0}, |
| {format: 'snorm16x2', offset: 1820, shaderLocation: 20}, |
| {format: 'uint32x4', offset: 1328, shaderLocation: 19}, |
| {format: 'uint16x4', offset: 2148, shaderLocation: 16}, |
| {format: 'float32', offset: 1284, shaderLocation: 1}, |
| {format: 'snorm16x2', offset: 2384, shaderLocation: 18}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'uint8x2', offset: 30292, shaderLocation: 14}, |
| {format: 'uint32x3', offset: 64476, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 3664, shaderLocation: 5}, |
| {format: 'unorm16x4', offset: 1684, shaderLocation: 13}, |
| {format: 'unorm16x4', offset: 41872, shaderLocation: 9}, |
| {format: 'unorm10-10-10-2', offset: 920, shaderLocation: 23}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', unclippedDepth: true}, |
| }); |
| offscreenCanvas7.width = 1505; |
| let bindGroup14 = device0.createBindGroup({layout: bindGroupLayout6, entries: []}); |
| let commandEncoder54 = device0.createCommandEncoder({label: '\u8f88\u0130\u8197\u02f4\u987d\u0cfa'}); |
| let textureView65 = texture17.createView({aspect: 'all', baseMipLevel: 4}); |
| try { |
| commandEncoder41.copyTextureToBuffer({ |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 516 widthInBlocks: 129 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 12312 */ |
| offset: 12312, |
| bytesPerRow: 768, |
| buffer: buffer1, |
| }, {width: 129, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder13.clearBuffer(buffer7, 3820, 2372); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 13660, new Float32Array(56999), 47695, 7344); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer2), /* required buffer size: 591 */ |
| {offset: 591, bytesPerRow: 60}, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let querySet20 = device0.createQuerySet({type: 'occlusion', count: 886}); |
| let texture53 = device0.createTexture({ |
| label: '\udbf3\u07ac\u2220\u{1fb5f}\u0efe', |
| size: {width: 640}, |
| dimension: '1d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint', 'rg16sint'], |
| }); |
| let textureView66 = texture1.createView({label: '\u8b44\u7904\u3bb7\u{1f829}\u7c06\u{1fa9f}\u{1f884}\u648c\u{1fbd9}\u{1fcd0}\ua382'}); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(480791402, 42260, 746038255, 412667292); |
| } catch {} |
| try { |
| commandEncoder50.copyBufferToBuffer(buffer3, 25196, buffer10, 69832, 15136); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder53.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 91, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1360 widthInBlocks: 340 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 65776 */ |
| offset: 65776, |
| buffer: buffer10, |
| }, {width: 340, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| let gpuCanvasContext4 = offscreenCanvas9.getContext('webgpu'); |
| let offscreenCanvas10 = new OffscreenCanvas(184, 475); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({ |
| label: '\u19fb\uc605\u5870\u{1fdc2}\u{1fcd6}\uc43b\u0c81\u{1f67b}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| }); |
| let externalTexture26 = device0.importExternalTexture({ |
| label: '\u{1fdd5}\u{1f6ef}\uca91\u{1fdf6}\u928c\ua3a6\u{1fbb3}\u0f9c', |
| source: video7, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup8, new Uint32Array(7367), 7068, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline14); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let pipeline54 = device0.createRenderPipeline({ |
| label: '\u066a\ub4e7\u0107\ub74e\u55aa\u0130\u0863\u72ba\u07b8\u9450', |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule7, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, { |
| format: 'r16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'r32sint', writeMask: 0}, {format: 'rgba8unorm-srgb', writeMask: 0}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: {compare: 'less', failOp: 'zero', depthFailOp: 'zero', passOp: 'invert'}, |
| stencilBack: {compare: 'less-equal', failOp: 'invert', depthFailOp: 'increment-wrap', passOp: 'decrement-wrap'}, |
| stencilReadMask: 384223809, |
| stencilWriteMask: 2190220319, |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'snorm16x4', offset: 59492, shaderLocation: 16}, |
| {format: 'float32x4', offset: 6420, shaderLocation: 6}, |
| {format: 'uint8x2', offset: 18720, shaderLocation: 7}, |
| {format: 'uint16x4', offset: 180, shaderLocation: 9}, |
| {format: 'uint16x2', offset: 5512, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 11844, |
| attributes: [ |
| {format: 'snorm16x4', offset: 2792, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 10208, shaderLocation: 14}, |
| {format: 'uint8x2', offset: 140, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 52008, |
| attributes: [ |
| {format: 'sint8x4', offset: 5356, shaderLocation: 10}, |
| {format: 'uint32', offset: 4356, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 3552, shaderLocation: 1}, |
| {format: 'uint16x2', offset: 3492, shaderLocation: 18}, |
| {format: 'sint8x4', offset: 7212, shaderLocation: 22}, |
| {format: 'uint32x3', offset: 4788, shaderLocation: 21}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x2', offset: 15472, shaderLocation: 12}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let buffer13 = device0.createBuffer({ |
| label: '\u0429\u34e3\u3225\u0fbb\ucd91', |
| size: 103866, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| let computePassEncoder25 = commandEncoder13.beginComputePass(); |
| let renderBundle30 = renderBundleEncoder16.finish({label: '\u{1f7dd}\u0b60\u676a\u{1f7aa}\u0663'}); |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 40672); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 19364); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(6, buffer8, 130344, 28707); |
| } catch {} |
| try { |
| commandEncoder39.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 42, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture28, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 16, height: 3, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder50.resolveQuerySet(querySet7, 561, 422, buffer10, 9472); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 7520, new DataView(new ArrayBuffer(61933)), 28625, 16848); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(56), /* required buffer size: 2048 */ |
| {offset: 884, rowsPerImage: 213}, {width: 582, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline55 = device0.createComputePipeline({layout: pipelineLayout6, compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}}); |
| let pipeline56 = device0.createRenderPipeline({ |
| label: '\uec72\uc42e\u5288', |
| layout: pipelineLayout7, |
| multisample: {mask: 0x2a809c21}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint', writeMask: 0}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'always', |
| stencilFront: {compare: 'less', depthFailOp: 'zero', passOp: 'invert'}, |
| stencilBack: {compare: 'less', failOp: 'invert', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'}, |
| stencilReadMask: 2179728820, |
| stencilWriteMask: 2039824236, |
| depthBias: -573077692, |
| depthBiasSlopeScale: 811.5269791949223, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 1536, |
| attributes: [ |
| {format: 'uint8x2', offset: 16, shaderLocation: 2}, |
| {format: 'float32x4', offset: 16, shaderLocation: 9}, |
| {format: 'float16x2', offset: 544, shaderLocation: 0}, |
| {format: 'float32', offset: 676, shaderLocation: 18}, |
| {format: 'snorm8x2', offset: 128, shaderLocation: 5}, |
| {format: 'float32', offset: 172, shaderLocation: 20}, |
| {format: 'uint8x2', offset: 360, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 296, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 9084, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x3', offset: 4008, shaderLocation: 4}, |
| {format: 'uint32', offset: 8936, shaderLocation: 19}, |
| ], |
| }, |
| { |
| arrayStride: 31808, |
| attributes: [ |
| {format: 'float32', offset: 464, shaderLocation: 3}, |
| {format: 'unorm8x4', offset: 856, shaderLocation: 21}, |
| {format: 'unorm16x2', offset: 3756, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 11592, shaderLocation: 16}, |
| {format: 'snorm8x4', offset: 4200, shaderLocation: 13}, |
| {format: 'uint8x4', offset: 3320, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{format: 'float16x2', offset: 5376, shaderLocation: 22}], |
| }, |
| { |
| arrayStride: 19152, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x2', offset: 1376, shaderLocation: 14}, |
| {format: 'snorm16x2', offset: 2244, shaderLocation: 23}, |
| {format: 'float32x2', offset: 2132, shaderLocation: 12}, |
| ], |
| }, |
| { |
| arrayStride: 18324, |
| stepMode: 'vertex', |
| attributes: [{format: 'uint16x2', offset: 12448, shaderLocation: 8}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| offscreenCanvas7.getContext('webgl'); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| label: '\ucba0\u02d7\u4408', |
| layout: bindGroupLayout5, |
| entries: [{binding: 4420, resource: externalTexture8}, {binding: 981, resource: textureView59}], |
| }); |
| let commandEncoder55 = device0.createCommandEncoder({label: '\u1c51\u0cbe\u1e23\u{1fc0e}\u3c6b\u1706\u60d6\u{1f646}\u3db6\u0f00\uc019'}); |
| try { |
| computePassEncoder19.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(1008692517, 692608217, 791040851, 653648269); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 56344); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(6, buffer8, 0, 45614); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData5, |
| origin: { x: 26, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| label: '\u3e97\u{1f9fc}\u347b\ucbb7\uf46b\u0c66\u4f16\u1948', |
| layout: bindGroupLayout3, |
| entries: [{binding: 6255, resource: sampler22}], |
| }); |
| let texture54 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView67 = texture53.createView({}); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({ |
| label: '\uccc4\u5293\u0ed0\u0461\u8dbb', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| }); |
| try { |
| computePassEncoder17.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer8, 'uint32'); |
| } catch {} |
| try { |
| commandEncoder23.clearBuffer(buffer0, 154984, 118764); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 27448, new DataView(new ArrayBuffer(63911)), 26903, 1148); |
| } catch {} |
| let promise19 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}}); |
| try { |
| await promise18; |
| } catch {} |
| gc(); |
| let texture55 = device0.createTexture({ |
| label: '\u02b7\ub4b3\u7251\u{1fada}\u08a4\u{1f7c6}\uc39a\u{1f95b}\u{1f6b1}', |
| size: {width: 298, height: 16, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint', 'rg8uint'], |
| }); |
| let externalTexture27 = device0.importExternalTexture({ |
| label: '\u5926\u0a6e\u{1f723}\u{1ffb7}\u0d1e\u22e0\u895b\u{1fe0b}', |
| source: video3, |
| colorSpace: 'srgb', |
| }); |
| try { |
| renderBundleEncoder5.draw(175141185, 633559678, 770126478, 1209921189); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 41888); |
| } catch {} |
| try { |
| renderBundleEncoder25.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder47.copyTextureToBuffer({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 86, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1392 widthInBlocks: 696 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 33776 */ |
| offset: 33776, |
| bytesPerRow: 1536, |
| rowsPerImage: 279, |
| buffer: buffer1, |
| }, {width: 696, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToTexture({ |
| texture: texture19, |
| mipLevel: 0, |
| origin: {x: 55, y: 13, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 1, |
| origin: {x: 1, y: 2, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 58, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 5344, new Float32Array(33914), 14851, 1512); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 6, y: 5 }, |
| flipY: false, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| label: '\u{1f996}\u0935\u1c79\u{1fd32}\ud67c', |
| layout: bindGroupLayout3, |
| entries: [{binding: 6255, resource: sampler21}], |
| }); |
| let commandEncoder56 = device0.createCommandEncoder({label: '\u041a\uf2c2\u{1f7ad}\ube6f'}); |
| let textureView68 = texture4.createView({mipLevelCount: 1}); |
| let computePassEncoder26 = commandEncoder46.beginComputePass({}); |
| let renderBundle31 = renderBundleEncoder19.finish(); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer11, 37192); |
| } catch {} |
| try { |
| commandEncoder31.clearBuffer(buffer7, 1620, 3028); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder22.pushDebugGroup('\u2827'); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(offscreenCanvas7); |
| let bindGroupLayout14 = pipeline3.getBindGroupLayout(1); |
| let texture56 = device0.createTexture({ |
| label: '\u07c1\uc6c0\ua30b\u{1fa4a}\u{1fee2}\ua527\uece1\u{1fd9c}\u{1f88f}', |
| size: [320, 40, 9], |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32sint', 'r32sint', 'r32sint'], |
| }); |
| let renderBundle32 = renderBundleEncoder21.finish({label: '\u09bd\u6e9e\u051b\u44c7\u897f\u0346\u00d1\u0691\u9abe\u{1f961}\uecb0'}); |
| let externalTexture28 = device0.importExternalTexture({label: '\u{1f622}\u8fa5\u0958\u9e60', source: videoFrame1, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder22.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(1109122790); |
| } catch {} |
| try { |
| commandEncoder41.clearBuffer(buffer10, 52004, 11840); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 9, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(new ArrayBuffer(72)), /* required buffer size: 978 */ |
| {offset: 976, rowsPerImage: 40}, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroupLayout15 = device0.createBindGroupLayout({ |
| label: '\u7dc0\u0f99', |
| entries: [ |
| { |
| binding: 6280, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4936, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup18 = device0.createBindGroup({ |
| label: '\u0893\u0e7d\u6018\u{1fe6b}\u6d37\u02a0\u021a', |
| layout: bindGroupLayout1, |
| entries: [{binding: 1494, resource: sampler9}], |
| }); |
| let texture57 = device0.createTexture({ |
| label: '\u{1f89f}\u08cb\u0019\ufb47\u8412\u9470\u0c29\u{1f8ab}\u0787\u6ea1', |
| size: [150, 24, 1], |
| mipLevelCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg16sint'], |
| }); |
| let renderBundle33 = renderBundleEncoder9.finish({}); |
| let externalTexture29 = device0.importExternalTexture({label: '\u03e6\u{1fc33}\u7382\u0db5', source: video4, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder5.setBindGroup(6, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(1, bindGroup16, new Uint32Array(3066), 2429, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(1, buffer3, 0, 4915); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer8, 129608, buffer10, 70240, 2256); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder55.copyTextureToBuffer({ |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 30, y: 3, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 488 widthInBlocks: 244 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 22148 */ |
| offset: 20124, |
| bytesPerRow: 512, |
| buffer: buffer1, |
| }, {width: 244, height: 4, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder39.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 7, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline57 = device0.createRenderPipeline({ |
| label: '\u0b94\u{1fbbe}\u082e\u{1fbcf}\u90ea\uea5c\udda2\u{1fc7c}\u05e3\u6fb3\ud59e', |
| layout: pipelineLayout1, |
| multisample: {count: 4, mask: 0x8d5de931}, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rg16sint', writeMask: 0}, {format: 'r16uint'}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: {compare: 'greater', failOp: 'zero', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'equal', failOp: 'increment-clamp', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'}, |
| stencilReadMask: 2130665333, |
| stencilWriteMask: 1741280454, |
| depthBiasClamp: 0.0, |
| }, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 9904, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 5940, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32x3', offset: 328, shaderLocation: 23}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| document.body.prepend(video4); |
| let bindGroupLayout16 = device0.createBindGroupLayout({ |
| label: '\u{1fe16}\u57fe\u{1f6ae}\u3cb6\uc5d5\u7938', |
| entries: [ |
| {binding: 751, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 4059, |
| visibility: 0, |
| texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 715, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder57 = device0.createCommandEncoder(); |
| let querySet21 = device0.createQuerySet({type: 'occlusion', count: 2705}); |
| let commandBuffer18 = commandEncoder47.finish({label: '\u9ee4\u69b9'}); |
| let texture58 = device0.createTexture({ |
| label: '\u0114\u03c6\u9eb0\u{1fdd4}\u0d2c\u{1f9b5}\u3705\u0a23\u0ab3', |
| size: [1280], |
| dimension: '1d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| }); |
| let textureView69 = texture6.createView({ |
| label: '\uba40\u9bcd\u7976\ub63f\u{1fc1f}\u{1f6d6}\u{1fbcc}\u0ac0', |
| format: 'bgra8unorm', |
| baseMipLevel: 0, |
| }); |
| try { |
| renderBundleEncoder5.drawIndexed(281765647, 1070543389, 253658881, 158153798, 1057263637); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 122240); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 56 */ |
| offset: 56, |
| buffer: buffer13, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer13); |
| } catch {} |
| try { |
| commandEncoder39.resolveQuerySet(querySet4, 2131, 1183, buffer10, 12288); |
| } catch {} |
| try { |
| computePassEncoder17.insertDebugMarker('\ub3ad'); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let videoFrame4 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let commandEncoder58 = device0.createCommandEncoder(); |
| let querySet22 = device0.createQuerySet({label: '\u0fda\udb6f\u2605\u070d\u4983', type: 'occlusion', count: 3335}); |
| let textureView70 = texture55.createView({label: '\u3326\u{1fae9}\u0769\u1607\uc1e0\u7230\u4834', baseMipLevel: 1}); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb']}); |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 43192); |
| } catch {} |
| try { |
| renderBundleEncoder25.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToBuffer(buffer3, 25336, buffer0, 274648, 584); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 24920 */ |
| offset: 24920, |
| buffer: buffer13, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer13); |
| } catch {} |
| try { |
| commandEncoder50.copyTextureToBuffer({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 38724 */ |
| offset: 38724, |
| bytesPerRow: 512, |
| buffer: buffer1, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder56.resolveQuerySet(querySet22, 684, 874, buffer10, 33792); |
| } catch {} |
| try { |
| renderBundleEncoder22.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 164172, new Int16Array(52063), 15723, 908); |
| } catch {} |
| let canvas4 = document.createElement('canvas'); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let texture59 = device0.createTexture({ |
| label: '\u15b4\u02a5\u0ad4', |
| size: {width: 600}, |
| dimension: '1d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint', 'rg16sint'], |
| }); |
| try { |
| computePassEncoder3.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(1, bindGroup18, new Uint32Array(8528), 6585, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(973841786, 532798242, 594808295, -154950368, 970247776); |
| } catch {} |
| try { |
| commandEncoder54.copyBufferToBuffer(buffer2, 368232, buffer1, 103420, 77280); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline58 = device0.createRenderPipeline({ |
| label: '\u0dd6\u707c\u491f\ud6d2\u{1fe8d}\u2fdd', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0x1722e61c}, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'r16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, { |
| format: 'r32sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rgba8unorm-srgb'}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilFront: {compare: 'never', failOp: 'invert', passOp: 'invert'}, |
| stencilBack: {compare: 'less', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'replace'}, |
| stencilReadMask: 1083443285, |
| stencilWriteMask: 2057062582, |
| depthBias: 1558257166, |
| depthBiasSlopeScale: 867.147508119042, |
| depthBiasClamp: 306.3855425420118, |
| }, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 46412, |
| attributes: [ |
| {format: 'float32x2', offset: 27152, shaderLocation: 5}, |
| {format: 'uint32x4', offset: 2916, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 8812, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x2', offset: 282, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 2996, shaderLocation: 6}, |
| {format: 'uint8x4', offset: 504, shaderLocation: 7}, |
| {format: 'float32x4', offset: 212, shaderLocation: 3}, |
| {format: 'uint16x4', offset: 2488, shaderLocation: 4}, |
| {format: 'unorm8x2', offset: 1530, shaderLocation: 17}, |
| {format: 'sint8x2', offset: 720, shaderLocation: 22}, |
| {format: 'float16x4', offset: 340, shaderLocation: 14}, |
| {format: 'uint32', offset: 540, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 2460, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 16888, |
| stepMode: 'instance', |
| attributes: [{format: 'sint32x2', offset: 2892, shaderLocation: 23}], |
| }, |
| { |
| arrayStride: 33748, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32', offset: 2276, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 8612, shaderLocation: 13}, |
| {format: 'uint32x2', offset: 2396, shaderLocation: 8}, |
| ], |
| }, |
| {arrayStride: 0, attributes: [{format: 'sint16x4', offset: 17268, shaderLocation: 18}]}, |
| { |
| arrayStride: 12356, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x2', offset: 492, shaderLocation: 21}], |
| }, |
| ], |
| }, |
| }); |
| let gpuCanvasContext5 = offscreenCanvas10.getContext('webgpu'); |
| let videoFrame5 = new VideoFrame(offscreenCanvas4, {timestamp: 0}); |
| let shaderModule8 = device0.createShaderModule({ |
| label: '\u{1faf0}\u{1f8ac}\ubb79\ucc1c\u36a9\u{1fdef}\u0831\u0dd2\ub5c5\u74b9\udd8c', |
| code: `@group(2) @binding(1530) |
| var<storage, read_write> global6: array<u32>; |
| @group(1) @binding(6303) |
| var<storage, read_write> function7: array<u32>; |
| @group(3) @binding(6255) |
| var<storage, read_write> n3: array<u32>; |
| @group(0) @binding(6255) |
| var<storage, read_write> function8: array<u32>; |
| |
| @compute @workgroup_size(4, 4, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(2) f0: vec4<u32>, |
| @location(0) f1: vec4<u32>, |
| @location(4) f2: vec4<f32>, |
| @location(3) f3: i32, |
| @location(1) f4: vec3<i32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @builtin(position) a1: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0() -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder60 = device0.createCommandEncoder({label: '\u5aa4\u44a9\u0164\u0696'}); |
| let textureView71 = texture6.createView({ |
| label: '\u1b76\u0f78\ufef0\uf68f\ud3bc\u0ca5\udcb8\u0511\u19d0', |
| format: 'bgra8unorm-srgb', |
| arrayLayerCount: 1, |
| }); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({ |
| label: '\ub11c\u0e35\u9c85', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| sampleCount: 1, |
| stencilReadOnly: true, |
| }); |
| let sampler24 = device0.createSampler({ |
| label: '\u{1fb8f}\u30be', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 21.39, |
| lodMaxClamp: 37.24, |
| }); |
| try { |
| renderBundleEncoder5.draw(1051270128); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 104160); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer8, 'uint16', 5356, 106182); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(6, buffer3, 0, 21897); |
| } catch {} |
| try { |
| commandEncoder52.clearBuffer(buffer0, 166792, 320832); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder54.insertDebugMarker('\u432d'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 57936, new DataView(new ArrayBuffer(43083)), 7475, 4184); |
| } catch {} |
| let textureView72 = texture30.createView({format: 'rgba8unorm', baseMipLevel: 2}); |
| try { |
| renderBundleEncoder5.draw(1149698838, 517044321, 841507741, 137474620); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 45148); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer11, 'uint32', 22812, 27648); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline27); |
| } catch {} |
| let arrayBuffer4 = buffer6.getMappedRange(57864, 8376); |
| try { |
| commandEncoder60.copyBufferToTexture({ |
| /* bytesInLastRow: 660 widthInBlocks: 165 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 21080 */ |
| offset: 21080, |
| rowsPerImage: 236, |
| buffer: buffer12, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 165, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer2), /* required buffer size: 813 */ |
| {offset: 809, bytesPerRow: 124}, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let externalTexture30 = device0.importExternalTexture({label: '\u0c9d\u9824\u4dbb\u89a7\ue778\ue138\u0b78', source: video5, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder5.draw(717650511, 1174521395, 394632629, 41599072); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToTexture({ |
| /* bytesInLastRow: 1240 widthInBlocks: 155 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 24568 */ |
| offset: 10528, |
| bytesPerRow: 1280, |
| buffer: buffer8, |
| }, { |
| texture: texture49, |
| mipLevel: 2, |
| origin: {x: 116, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 155, height: 11, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 1404, new BigUint64Array(45273), 6267, 2788); |
| } catch {} |
| let pipeline59 = await promise19; |
| gc(); |
| try { |
| canvas4.getContext('bitmaprenderer'); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| label: '\udfca\u0cd0\u4ea0\ua2c7\u950e\uebec\u0ffe', |
| layout: bindGroupLayout13, |
| entries: [{binding: 1530, resource: externalTexture23}], |
| }); |
| let commandBuffer19 = commandEncoder54.finish({label: '\u0f65\u952f\u0700\u0432'}); |
| let texture60 = device0.createTexture({ |
| label: '\u088e\u{1fd20}\u04ac\u4960\u0b5a\u06bd\u4c92\u3120\u0130\u0dae', |
| size: {width: 88, height: 48, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView73 = texture44.createView({label: '\u9dca\u0858\ue74d\u{1f87e}', baseMipLevel: 5}); |
| let sampler25 = device0.createSampler({ |
| label: '\u{1ffb0}\u4dc9\ud36f\u99d9\u0f9c\u05a2\u3851\u0fc8\u0d80\u0a0c', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 0.7736, |
| lodMaxClamp: 40.28, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(4, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 63308); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer8, 1132); |
| } catch {} |
| try { |
| renderBundleEncoder17.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 1, |
| origin: {x: 170, y: 5, z: 143}, |
| aspect: 'all', |
| }, new Int16Array(arrayBuffer3), /* required buffer size: 13638875 */ |
| {offset: 59, bytesPerRow: 213, rowsPerImage: 116}, {width: 100, height: 0, depthOrArrayLayers: 553}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 24, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img7, |
| origin: { x: 38, y: 47 }, |
| flipY: false, |
| }, { |
| texture: texture51, |
| mipLevel: 2, |
| origin: {x: 19, y: 16, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 35, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline60 = await promise15; |
| let imageBitmap2 = await createImageBitmap(img6); |
| let shaderModule9 = device0.createShaderModule({ |
| label: '\u{1fd3a}\u4927\u9714\ud359\u{1f8e2}\ue9f4\u80a0\u{1f742}\u7145', |
| code: `@group(1) @binding(6303) |
| var<storage, read_write> parameter2: array<u32>; |
| @group(0) @binding(3816) |
| var<storage, read_write> local4: array<u32>; |
| @group(0) @binding(4504) |
| var<storage, read_write> local5: array<u32>; |
| |
| @compute @workgroup_size(6, 1, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(1) f0: vec2<i32>, |
| @location(2) f1: vec4<u32>, |
| @location(4) f2: vec4<f32>, |
| @location(0) f3: vec4<u32>, |
| @location(3) f4: vec3<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(39) a0: vec3<f32>, @location(27) a1: vec3<f16>, @location(53) a2: vec4<f16>, @location(78) a3: vec2<f32>, @location(55) a4: vec4<i32>, @location(13) a5: f32, @location(45) a6: vec3<f32>, @location(64) a7: vec3<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S7 { |
| @location(8) f0: vec3<u32>, |
| @location(0) f1: vec2<f16>, |
| @location(15) f2: vec3<f16>, |
| @location(9) f3: vec4<f16>, |
| @location(19) f4: vec3<f32>, |
| @location(13) f5: vec3<f32>, |
| @location(22) f6: f32, |
| @location(21) f7: vec3<u32>, |
| @location(2) f8: f16, |
| @location(6) f9: vec2<f32> |
| } |
| struct VertexOutput0 { |
| @location(55) f80: vec4<i32>, |
| @builtin(position) f81: vec4<f32>, |
| @location(81) f82: vec3<f32>, |
| @location(51) f83: f32, |
| @location(85) f84: vec2<f16>, |
| @location(10) f85: vec2<u32>, |
| @location(15) f86: vec3<u32>, |
| @location(27) f87: vec3<f16>, |
| @location(64) f88: vec3<f32>, |
| @location(72) f89: vec2<f16>, |
| @location(13) f90: f32, |
| @location(78) f91: vec2<f32>, |
| @location(20) f92: vec4<u32>, |
| @location(45) f93: vec3<f32>, |
| @location(49) f94: u32, |
| @location(70) f95: vec3<u32>, |
| @location(68) f96: u32, |
| @location(46) f97: vec4<f32>, |
| @location(87) f98: vec4<i32>, |
| @location(67) f99: vec4<i32>, |
| @location(65) f100: vec4<f16>, |
| @location(42) f101: i32, |
| @location(82) f102: vec4<i32>, |
| @location(80) f103: vec4<u32>, |
| @location(39) f104: vec3<f32>, |
| @location(47) f105: vec2<f16>, |
| @location(9) f106: vec2<u32>, |
| @location(41) f107: u32, |
| @location(53) f108: vec4<f16>, |
| @location(1) f109: vec3<f16>, |
| @location(83) f110: vec3<f16>, |
| @location(43) f111: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(11) a0: vec4<f32>, @location(3) a1: vec3<f16>, @builtin(instance_index) a2: u32, @location(14) a3: vec3<u32>, @location(20) a4: vec2<f32>, @location(1) a5: vec2<f16>, @location(18) a6: f32, a7: S7) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let commandEncoder61 = device0.createCommandEncoder({label: '\u{1f92c}\u0924\uaddf\ubb9f\u03f3'}); |
| let textureView74 = texture42.createView({ |
| label: '\ude05\u0ccf\u66f8\u47c2\u0bcf\ufc9e\u0ebd\u05df\u7c54\u0c5f\u2ced', |
| dimension: '2d-array', |
| baseMipLevel: 1, |
| mipLevelCount: 2, |
| }); |
| let sampler26 = device0.createSampler({ |
| label: '\u0723\u{1f73f}\uda5b', |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 66.34, |
| lodMaxClamp: 84.65, |
| }); |
| let externalTexture31 = device0.importExternalTexture({label: '\u707d\u07ee\u{1fb56}\u47b7\u47a0', source: video0}); |
| try { |
| renderBundleEncoder5.draw(359290827, 294001142); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 98992); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(3063, undefined, 3732531649, 357667004); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToBuffer(buffer6, 151380, buffer0, 35592, 81256); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 77, y: 6, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(45650), /* required buffer size: 45650 */ |
| {offset: 124, bytesPerRow: 860, rowsPerImage: 271}, {width: 403, height: 53, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipelineLayout8 = device0.createPipelineLayout({ |
| label: '\u1729\u7ad9\u879b\ud7d5\u0398\u{1fa33}\u0d90\ubf4d\u7d3e', |
| bindGroupLayouts: [bindGroupLayout8], |
| }); |
| let commandEncoder62 = device0.createCommandEncoder({label: '\udbb5\u1920\u04c7\u{1fa93}\u5d7d\u51dd\u26b3\ua6c7\u{1f644}\u{1f9d2}\ufd8e'}); |
| let textureView75 = texture43.createView({label: '\u0454\u15f5\ua730\u2532\u8b0f\u06c9\u4371\ua087', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder5.drawIndexed(938195325, 1097123189, 1170703900, 1017505366); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer17, commandBuffer19, commandBuffer18]); |
| } catch {} |
| let promise20 = device0.createComputePipelineAsync({ |
| label: '\uf548\u613b', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline61 = device0.createRenderPipeline({ |
| label: '\u2cfe\u67bf\u8b29', |
| layout: pipelineLayout1, |
| multisample: {}, |
| fragment: { |
| module: shaderModule7, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: 0}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst'}, |
| }, |
| writeMask: GPUColorWrite.BLUE, |
| }], |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 1060, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x2', offset: 308, shaderLocation: 14}, |
| {format: 'uint16x4', offset: 460, shaderLocation: 21}, |
| {format: 'uint32x3', offset: 316, shaderLocation: 9}, |
| {format: 'uint32x4', offset: 472, shaderLocation: 18}, |
| {format: 'uint32', offset: 200, shaderLocation: 2}, |
| {format: 'float32x3', offset: 528, shaderLocation: 12}, |
| {format: 'snorm16x2', offset: 120, shaderLocation: 6}, |
| {format: 'snorm8x2', offset: 440, shaderLocation: 3}, |
| ], |
| }, |
| { |
| arrayStride: 5228, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x4', offset: 3392, shaderLocation: 10}, |
| {format: 'sint32x3', offset: 696, shaderLocation: 22}, |
| {format: 'uint8x2', offset: 1190, shaderLocation: 7}, |
| ], |
| }, |
| {arrayStride: 19948, attributes: []}, |
| { |
| arrayStride: 24568, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'unorm8x4', offset: 504, shaderLocation: 16}, |
| {format: 'uint8x4', offset: 5948, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 20676, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x4', offset: 472, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 4848, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let offscreenCanvas11 = new OffscreenCanvas(565, 839); |
| let commandEncoder63 = device0.createCommandEncoder(); |
| let texture61 = device0.createTexture({ |
| label: '\u04ef\ue793\u0d92', |
| size: [44, 24, 1], |
| mipLevelCount: 2, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg8uint'], |
| }); |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup18, new Uint32Array(6884), 96, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(803278759, 912821171, 429132427, 516104644); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(833730874, 470646116, 591670867); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer11, 'uint32', 104428, 8108); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(6, buffer8, 104876, 40436); |
| } catch {} |
| try { |
| commandEncoder52.copyBufferToTexture({ |
| /* bytesInLastRow: 1996 widthInBlocks: 499 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 8840 */ |
| offset: 8840, |
| buffer: buffer12, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 499, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder58.clearBuffer(buffer0, 192092, 236240); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroup20 = device0.createBindGroup({layout: bindGroupLayout7, entries: [{binding: 1530, resource: externalTexture17}]}); |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 15.40, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder18.setBindGroup(4, bindGroup0, new Uint32Array(9364), 9129, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(6, bindGroup4, []); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(327379316, 498268861, 119311789, 877039001); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline39); |
| } catch {} |
| let arrayBuffer5 = buffer7.getMappedRange(1624, 20); |
| try { |
| commandEncoder57.copyBufferToBuffer(buffer4, 232408, buffer10, 82368, 740); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder56.copyTextureToBuffer({ |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 181, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 512 widthInBlocks: 128 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 15472 */ |
| offset: 15472, |
| buffer: buffer10, |
| }, {width: 128, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder60.clearBuffer(buffer7, 1488, 1932); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| commandEncoder48.resolveQuerySet(querySet12, 3114, 257, buffer10, 79872); |
| } catch {} |
| let videoFrame6 = new VideoFrame(canvas1, {timestamp: 0}); |
| let shaderModule10 = device0.createShaderModule({ |
| label: '\u913c\u0b7a\u{1ff12}\u2abf\u6cc7\u{1f673}\u2141\ufb4c', |
| code: `@group(6) @binding(4420) |
| var<storage, read_write> local6: array<u32>; |
| @group(4) @binding(6303) |
| var<storage, read_write> type1: array<u32>; |
| @group(3) @binding(981) |
| var<storage, read_write> parameter3: array<u32>; |
| @group(3) @binding(4420) |
| var<storage, read_write> field1: array<u32>; |
| @group(1) @binding(981) |
| var<storage, read_write> function9: array<u32>; |
| @group(5) @binding(6255) |
| var<storage, read_write> type2: array<u32>; |
| @group(0) @binding(1494) |
| var<storage, read_write> field2: array<u32>; |
| @group(4) @binding(2593) |
| var<storage, read_write> field3: array<u32>; |
| @group(6) @binding(981) |
| var<storage, read_write> local7: array<u32>; |
| @group(2) @binding(4420) |
| var<storage, read_write> global7: array<u32>; |
| |
| @compute @workgroup_size(2, 2, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<i32>, |
| @location(3) f1: vec3<i32>, |
| @location(4) f2: vec4<f32>, |
| @location(0) f3: vec3<u32>, |
| @location(2) f4: vec2<u32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(position) a0: vec4<f32>, @builtin(sample_mask) a1: u32, @builtin(sample_index) a2: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(9) a0: vec4<i32>, @location(1) a1: vec2<f16>, @location(2) a2: vec3<f32>, @location(18) a3: vec3<i32>, @location(6) a4: vec3<f32>, @location(7) a5: vec2<i32>, @location(0) a6: vec2<i32>, @location(22) a7: vec3<f32>, @location(3) a8: i32, @location(11) a9: vec4<f32>, @location(17) a10: vec4<f32>, @location(19) a11: vec3<f32>, @location(8) a12: i32, @location(10) a13: vec2<i32>, @location(15) a14: f16, @location(14) a15: vec3<u32>, @location(23) a16: vec4<u32>, @builtin(vertex_index) a17: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let computePassEncoder27 = commandEncoder62.beginComputePass({label: '\u0d59\udae6\u0092\u{1f712}\u5ce2\u{1faa2}\u{1fb5a}\u{1fe67}\u0cbd\uccb0'}); |
| try { |
| computePassEncoder26.setPipeline(pipeline34); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer3); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToTexture({ |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 44, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture33, |
| mipLevel: 1, |
| origin: {x: 1, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 36, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder63.clearBuffer(buffer10, 69276, 12212); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| let promise21 = device0.createComputePipelineAsync({ |
| label: '\u{1fe49}\u{1fca6}\u433d\u6cfc', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule8, entryPoint: 'compute0', constants: {}}, |
| }); |
| let offscreenCanvas12 = new OffscreenCanvas(871, 642); |
| let commandEncoder64 = device0.createCommandEncoder({label: '\u0dc5\u03be\u0ff7\u{1ffd7}\uc780\uca48\u0e2b\u5e3f\u3bc4'}); |
| let renderBundle34 = renderBundleEncoder27.finish({label: '\u0157\uf14d\u{1f916}\uedf5\ufac8\u33e7\ube60\u9150'}); |
| try { |
| renderBundleEncoder5.draw(1177424598, 581667609, 1064092053, 675371702); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(366285739, 1136833401, 1095644137, 626615389, 1039781271); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(7, buffer3, 0, 2523); |
| } catch {} |
| try { |
| await buffer9.mapAsync(GPUMapMode.READ, 0, 42804); |
| } catch {} |
| let pipeline62 = await device0.createRenderPipelineAsync({ |
| label: '\u1fc0\u0622\u3b9f\u34cc\u0397\u{1fa45}\u{1fde2}', |
| layout: pipelineLayout5, |
| multisample: {count: 4, mask: 0xa51b5725}, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.GREEN}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r16uint'}, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 35944, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x4', offset: 1436, shaderLocation: 2}], |
| }, |
| ], |
| }, |
| }); |
| let offscreenCanvas13 = new OffscreenCanvas(276, 393); |
| let bindGroup21 = device0.createBindGroup({label: '\u{1fb85}\ubc6e', layout: bindGroupLayout1, entries: [{binding: 1494, resource: sampler0}]}); |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let texture62 = device0.createTexture({ |
| label: '\u03c4\ude3c\u5b91\u0ab8\u{1fd37}\u9a7f\u{1fce5}\u7786\u{1fd1d}\u254f', |
| size: [88], |
| dimension: '1d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm-srgb'], |
| }); |
| let textureView76 = texture42.createView({baseMipLevel: 1, mipLevelCount: 2, baseArrayLayer: 0}); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({ |
| label: '\u4317\u12ce\u0ab6', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let sampler28 = device0.createSampler({ |
| label: '\u0549\u{1fb27}\udcbc\u6271\u9383\u6e49\u{1f7df}\u0cbf\u0f99\u2988\u0fc0', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 96.63, |
| lodMaxClamp: 98.40, |
| maxAnisotropy: 14, |
| }); |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 155472); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas6, |
| origin: { x: 35, y: 155 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let canvas5 = document.createElement('canvas'); |
| let shaderModule11 = device0.createShaderModule({ |
| label: '\u{1fb71}\u0ee3\u{1fc16}\u26e7', |
| code: `@group(0) @binding(3816) |
| var<storage, read_write> global8: array<u32>; |
| @group(1) @binding(6303) |
| var<storage, read_write> parameter4: array<u32>; |
| @group(0) @binding(3513) |
| var<storage, read_write> function10: array<u32>; |
| @group(0) @binding(4504) |
| var<storage, read_write> type3: array<u32>; |
| |
| @compute @workgroup_size(4, 1, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(0) f0: vec4<u32>, |
| @location(4) f1: vec4<f32>, |
| @location(3) f2: vec4<i32>, |
| @location(2) f3: u32, |
| @location(1) f4: vec4<i32> |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S8 { |
| @location(7) f0: f16, |
| @location(18) f1: vec4<i32>, |
| @location(2) f2: vec2<u32>, |
| @location(4) f3: f16, |
| @location(15) f4: vec4<i32>, |
| @location(21) f5: vec2<i32>, |
| @location(9) f6: i32, |
| @location(1) f7: vec3<f32>, |
| @location(12) f8: vec3<f16>, |
| @location(11) f9: vec4<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(20) a0: vec2<i32>, @location(6) a1: vec2<f16>, @location(14) a2: vec3<i32>, @builtin(vertex_index) a3: u32, @location(0) a4: vec3<f16>, @location(8) a5: i32, @location(3) a6: vec2<i32>, @location(5) a7: vec3<u32>, @location(10) a8: u32, @location(16) a9: vec2<f16>, @location(23) a10: vec3<f32>, a11: S8) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let bindGroup22 = device0.createBindGroup({ |
| label: '\u6f7c\u05d2\u2784\u083c\uf687\u0a98\u0fd5\uc2ee\u0318', |
| layout: bindGroupLayout7, |
| entries: [{binding: 1530, resource: externalTexture27}], |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(1, bindGroup20, new Uint32Array(7962), 4568, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(1078392221, 994429757, 977237463, 574657940); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 136668); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(8, buffer8, 164980, 1079); |
| } catch {} |
| try { |
| commandEncoder58.copyBufferToBuffer(buffer8, 102836, buffer1, 167412, 3264); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder41.resolveQuerySet(querySet13, 407, 1, buffer10, 4352); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video2, |
| origin: { x: 0, y: 13 }, |
| flipY: false, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise22 = device0.createRenderPipelineAsync({ |
| label: '\ua53b\u7a1c\u0c15\u7ed4\u0a47\ue86b\u3843\u{1ff6a}\u2394\u449e\u8847', |
| layout: 'auto', |
| multisample: {mask: 0x48525eb5}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: {compare: 'less-equal', failOp: 'replace', passOp: 'increment-wrap'}, |
| stencilBack: {compare: 'never', failOp: 'keep', depthFailOp: 'decrement-wrap', passOp: 'increment-clamp'}, |
| depthBias: -939802962, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 668, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 28, shaderLocation: 18}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 6}, |
| {format: 'sint8x4', offset: 84, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let gpuCanvasContext6 = canvas5.getContext('webgpu'); |
| let canvas6 = document.createElement('canvas'); |
| let texture63 = device0.createTexture({ |
| label: '\u6ce7\u2da2\uf2b7\u75eb\uabee', |
| size: [150], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView77 = texture61.createView({ |
| label: '\u5b6e\u6870\u1703\u{1f947}\u0c3c\ub1cf\u0756\u{1fed1}\u3f98\u047c\u0b71', |
| dimension: '2d-array', |
| baseMipLevel: 1, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup6, new Uint32Array(6993), 1584, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(2, bindGroup14, []); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(779006025, 776038152, 270222099, 783545409, 850878946); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToBuffer({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1150 widthInBlocks: 575 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1048 */ |
| offset: 1048, |
| buffer: buffer10, |
| }, {width: 575, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder39.clearBuffer(buffer1, 29436, 245228); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder58.resolveQuerySet(querySet15, 651, 714, buffer10, 62208); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(img5); |
| let bindGroup23 = device0.createBindGroup({layout: bindGroupLayout3, entries: [{binding: 6255, resource: sampler4}]}); |
| let commandEncoder66 = device0.createCommandEncoder({label: '\u{1ff2b}\ud6f4\u1d6b\u0e6b'}); |
| let textureView78 = texture26.createView({ |
| label: '\ude57\u8e02\u8632\u7c78\u059a\u02cc\u0a27\u{1f720}\u6731\ue425\u{1ff78}', |
| dimension: '2d-array', |
| format: 'bgra8unorm-srgb', |
| }); |
| let renderBundleEncoder31 = device0.createRenderBundleEncoder({ |
| label: '\u2dc7\ubc12\u5834\u{1f7d2}\u0ce8\u02ef\u{1f85c}\u{1f9b4}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: false, |
| }); |
| let renderBundle35 = renderBundleEncoder4.finish(); |
| try { |
| computePassEncoder15.setBindGroup(4, bindGroup4, new Uint32Array(4391), 3576, 0); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 15400); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline39); |
| } catch {} |
| try { |
| buffer6.destroy(); |
| } catch {} |
| let querySet23 = device0.createQuerySet({label: '\uab6d\u0c9e\u5ee8\uac24\ue1a4\ucf2d\u8e3a\u04ca\uf09b', type: 'occlusion', count: 2376}); |
| let commandBuffer20 = commandEncoder65.finish({label: '\u{1f6a4}\u0cdb\ua061\u{1fb0c}'}); |
| let renderBundleEncoder32 = device0.createRenderBundleEncoder({ |
| label: '\u{1fb3f}\u{1fa56}\u00c5\ua09e\u0748\u53a7\u0835', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let renderBundle36 = renderBundleEncoder4.finish({label: '\ue99e\u8572\u{1f9b7}\u72dd\u{1fef3}'}); |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 52820); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 20896); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline15); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToBuffer(buffer8, 91820, buffer7, 4100, 1660); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| let pipeline63 = device0.createComputePipeline({ |
| label: '\u0c9b\u71ff\u041e\u{1f989}\u278c\u7e93\ub87b\u9ceb\u7832\u{1f665}\u8c9d', |
| layout: pipelineLayout8, |
| compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}}, |
| }); |
| let bindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2842, |
| visibility: 0, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let textureView79 = texture37.createView({baseMipLevel: 2, mipLevelCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(971579834, 1080628513, 437220862, 565030249); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(278107690); |
| } catch {} |
| offscreenCanvas12.width = 499; |
| let commandEncoder67 = device0.createCommandEncoder({label: '\u3510\u975b\u{1f7e6}\u6049\u090e\ueee7\u1d47\u{1f791}'}); |
| let querySet24 = device0.createQuerySet({label: '\uc2a6\uce4b\u0ad5\u5e1b\u097d\u{1fdf5}\u072a\ub5c4', type: 'occlusion', count: 2471}); |
| let externalTexture32 = device0.importExternalTexture({label: '\u02ea\u{1fb78}', source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(54343411); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 19296); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 145596, new Int16Array(27865), 23691, 436); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 24, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas3, |
| origin: { x: 312, y: 80 }, |
| flipY: false, |
| }, { |
| texture: texture51, |
| mipLevel: 2, |
| origin: {x: 64, y: 12, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline64 = await device0.createComputePipelineAsync({ |
| label: '\ufdd6\u67f1\u2a1a\u20bc', |
| layout: pipelineLayout6, |
| compute: {module: shaderModule5, entryPoint: 'compute0', constants: {}}, |
| }); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 2.650, |
| lodMaxClamp: 29.55, |
| }); |
| try { |
| computePassEncoder15.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(4, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(427082153, 98433808, 1147920395); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToBuffer({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 75108 */ |
| offset: 75108, |
| buffer: buffer10, |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture60, |
| mipLevel: 3, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(40), /* required buffer size: 461 */ |
| {offset: 461}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let imageBitmap4 = await createImageBitmap(img2); |
| try { |
| canvas6.getContext('bitmaprenderer'); |
| } catch {} |
| let commandEncoder68 = device0.createCommandEncoder(); |
| let textureView80 = texture12.createView({ |
| label: '\u07f6\ua955\u045e\u3782\ufca0\u0e8d\u{1f880}\u{1f74d}', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| baseArrayLayer: 0, |
| }); |
| let renderBundle37 = renderBundleEncoder6.finish({}); |
| try { |
| renderBundleEncoder5.drawIndexed(738409163, 1035487430); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToTexture({ |
| /* bytesInLastRow: 612 widthInBlocks: 153 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 6216 */ |
| offset: 6216, |
| buffer: buffer5, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 153, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 150, height: 24, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 25, y: 82 }, |
| flipY: true, |
| }, { |
| texture: texture51, |
| mipLevel: 2, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let video8 = await videoWithData(); |
| let commandEncoder69 = device0.createCommandEncoder({label: '\u7a1e\u025f\u05bd\u8002'}); |
| let commandBuffer21 = commandEncoder34.finish({label: '\u31a0\u0c00\u0618\u0c92\ua5d4\u{1fb33}'}); |
| let texture64 = device0.createTexture({ |
| label: '\ua1d6\u3e03\u546e\u68c3\uf147\u8235\uc01e', |
| size: [320, 40, 168], |
| mipLevelCount: 6, |
| sampleCount: 1, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg8uint', 'rg8uint'], |
| }); |
| let renderBundle38 = renderBundleEncoder16.finish({label: '\u0d53\uaca4\u7ce0\u5245\ufe01\u08ed\u04a4\u44fb\u{1faa9}\u8868\u9ff3'}); |
| try { |
| renderBundleEncoder31.setBindGroup(3, bindGroup8, []); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer11, 8356); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToTexture({ |
| /* bytesInLastRow: 198 widthInBlocks: 99 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 12794 */ |
| offset: 12794, |
| bytesPerRow: 256, |
| buffer: buffer3, |
| }, { |
| texture: texture3, |
| mipLevel: 3, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 99, height: 20, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 96596, new BigUint64Array(33087), 2505, 7372); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| let pipeline65 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg16sint'}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, { |
| format: 'rgba8unorm-srgb', |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 11384, |
| stepMode: 'vertex', |
| attributes: [{format: 'uint32x4', offset: 3348, shaderLocation: 16}], |
| }, |
| { |
| arrayStride: 40504, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint8x2', offset: 17254, shaderLocation: 13}, |
| {format: 'unorm16x4', offset: 12908, shaderLocation: 23}, |
| {format: 'float32x2', offset: 300, shaderLocation: 19}, |
| {format: 'sint8x2', offset: 4034, shaderLocation: 22}, |
| {format: 'unorm8x2', offset: 8306, shaderLocation: 11}, |
| {format: 'uint32x2', offset: 7232, shaderLocation: 6}, |
| {format: 'uint32x2', offset: 3724, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 11072, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32x2', offset: 332, shaderLocation: 5}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let renderBundleEncoder33 = device0.createRenderBundleEncoder({ |
| label: '\u0316\u4146\u582f\u0857\u2d6d\u0992\ue931', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| }); |
| try { |
| commandEncoder37.resolveQuerySet(querySet9, 663, 6, buffer10, 37888); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap2, |
| origin: { x: 25, y: 37 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline66 = await device0.createRenderPipelineAsync({ |
| label: '\uef2d\u4166\u0bcc\uc515\u0c62\u03e2\u477c\u0564\u5e17', |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule10, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r16uint'}, {format: 'r32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba8unorm-srgb', writeMask: 0}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'never', |
| stencilFront: {compare: 'equal', failOp: 'invert', depthFailOp: 'replace', passOp: 'zero'}, |
| stencilBack: {compare: 'never', failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'decrement-clamp'}, |
| stencilReadMask: 556530109, |
| stencilWriteMask: 2267235253, |
| depthBias: 1815059020, |
| depthBiasSlopeScale: 326.1545800933313, |
| depthBiasClamp: -90.32837387968978, |
| }, |
| vertex: { |
| module: shaderModule10, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 0, attributes: []}, |
| { |
| arrayStride: 13188, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x3', offset: 284, shaderLocation: 14}, |
| {format: 'snorm8x2', offset: 3888, shaderLocation: 15}, |
| ], |
| }, |
| { |
| arrayStride: 5492, |
| attributes: [ |
| {format: 'sint8x2', offset: 578, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 344, shaderLocation: 2}, |
| {format: 'sint32x4', offset: 3460, shaderLocation: 0}, |
| {format: 'sint32x2', offset: 1336, shaderLocation: 3}, |
| {format: 'uint32x3', offset: 676, shaderLocation: 23}, |
| {format: 'float16x2', offset: 184, shaderLocation: 19}, |
| {format: 'float32', offset: 5340, shaderLocation: 17}, |
| {format: 'float16x2', offset: 664, shaderLocation: 1}, |
| {format: 'float32x4', offset: 1812, shaderLocation: 6}, |
| {format: 'sint32', offset: 764, shaderLocation: 10}, |
| {format: 'sint16x2', offset: 468, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 22040, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x2', offset: 5936, shaderLocation: 22}, |
| {format: 'sint8x4', offset: 352, shaderLocation: 8}, |
| ], |
| }, |
| { |
| arrayStride: 3456, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x4', offset: 116, shaderLocation: 11}, |
| {format: 'sint8x4', offset: 44, shaderLocation: 18}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'ccw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) }; |
| } catch {} |
| let bindGroupLayout18 = pipeline16.getBindGroupLayout(1); |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let externalTexture33 = device0.importExternalTexture({ |
| label: '\u0b04\u{1f754}\u07d3\u0a5a\u{1fea6}\u09e2\u6887\u8c1f\u6e4e', |
| source: videoFrame2, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup19, new Uint32Array(4857), 4388, 0); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline59); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(5, bindGroup3, new Uint32Array(3860), 143, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder4.copyBufferToBuffer(buffer2, 43992, buffer0, 485612, 13144); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder63.copyTextureToBuffer({ |
| texture: texture61, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 10734 */ |
| offset: 8172, |
| bytesPerRow: 256, |
| buffer: buffer1, |
| }, {width: 1, height: 11, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder63.clearBuffer(buffer0, 481584, 7104); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder4.resolveQuerySet(querySet13, 105, 1498, buffer10, 1280); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 1968); |
| } catch {} |
| try { |
| commandEncoder70.copyBufferToBuffer(buffer5, 23412, buffer10, 26268, 17520); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 2, |
| origin: {x: 14, y: 0, z: 28}, |
| aspect: 'all', |
| }, new DataView(arrayBuffer1), /* required buffer size: 1862069 */ |
| {offset: 421, bytesPerRow: 346, rowsPerImage: 298}, {width: 42, height: 17, depthOrArrayLayers: 19}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 600, height: 96, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 13, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 227, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 22, height: 96, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline67 = device0.createComputePipeline({ |
| label: '\uec11\u3cf1\u0a61\u2dec\u42df\u0d4f\u{1fb3b}\u9a3c\u370d\uf13b', |
| layout: pipelineLayout6, |
| compute: {module: shaderModule5, entryPoint: 'compute0', constants: {}}, |
| }); |
| let commandEncoder71 = device0.createCommandEncoder(); |
| let querySet25 = device0.createQuerySet({type: 'occlusion', count: 1947}); |
| let commandBuffer22 = commandEncoder60.finish({label: '\u807a\u0f3b\u0721\u0383\u0829\ue818\ud7d8\u0856\ucc41'}); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup14, []); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(1117369171, 1111944056); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let querySet26 = device0.createQuerySet({type: 'occlusion', count: 2770}); |
| let textureView81 = texture4.createView({label: '\ub574\u3ca8\u0f44\u{1fa78}\u2f0c\u{1f8bf}\u045b\u042a'}); |
| let computePassEncoder28 = commandEncoder63.beginComputePass({label: '\u00f7\u15e4\u3548\ua801\u03aa\uef31\u07eb\u4164\ub552'}); |
| let renderBundleEncoder34 = device0.createRenderBundleEncoder({ |
| label: '\uded1\uec42\u0c76\u9d8a\udc0b\u{1f98e}\u0540\u9451\ubdae\u4d69\u59f0', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder8.draw(185902335); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(245875969, 794376314, 214554006, -839098182, 78493661); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer1, 14356); |
| } catch {} |
| try { |
| renderBundleEncoder31.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder33.copyTextureToTexture({ |
| texture: texture42, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 12, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder51.clearBuffer(buffer7, 5808, 564); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 31, y: 54 }, |
| flipY: true, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img1); |
| let commandEncoder72 = device0.createCommandEncoder({label: '\u8c47\u{1f92f}\u52af\u05cc\u0a03'}); |
| try { |
| renderBundleEncoder33.setVertexBuffer(7, buffer3); |
| } catch {} |
| try { |
| commandEncoder58.copyBufferToBuffer(buffer5, 61992, buffer1, 58944, 38768); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder37.resolveQuerySet(querySet26, 112, 43, buffer10, 16640); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer21, commandBuffer20]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 68676, new DataView(new ArrayBuffer(49599)), 22827, 3244); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture28, |
| mipLevel: 1, |
| origin: {x: 89, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer2), /* required buffer size: 3992443 */ |
| {offset: 507, bytesPerRow: 1234, rowsPerImage: 247}, {width: 295, height: 24, depthOrArrayLayers: 14}); |
| } catch {} |
| let pipeline68 = device0.createComputePipeline({ |
| label: '\u0f16\ue819', |
| layout: pipelineLayout8, |
| compute: {module: shaderModule8, entryPoint: 'compute0', constants: {}}, |
| }); |
| document.body.prepend(video1); |
| let commandEncoder73 = device0.createCommandEncoder({label: '\u5aef\u0865\u0df6'}); |
| let arrayBuffer6 = buffer7.getMappedRange(1776, 260); |
| try { |
| commandEncoder61.copyTextureToBuffer({ |
| texture: texture17, |
| mipLevel: 1, |
| origin: {x: 12, y: 11, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 224 widthInBlocks: 56 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 45816 */ |
| offset: 32280, |
| bytesPerRow: 512, |
| buffer: buffer1, |
| }, {width: 56, height: 27, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder57.clearBuffer(buffer0, 38268, 265512); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| let pipeline69 = device0.createRenderPipeline({ |
| label: '\u2f47\u7c53', |
| layout: pipelineLayout8, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, { |
| format: 'rg16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }, { |
| format: 'r16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }, {format: 'r32sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'equal', |
| stencilFront: {compare: 'greater-equal', failOp: 'replace', depthFailOp: 'zero', passOp: 'replace'}, |
| stencilBack: { |
| compare: 'greater', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'decrement-clamp', |
| }, |
| stencilWriteMask: 1076503970, |
| depthBias: -894750923, |
| depthBiasSlopeScale: 0.0, |
| depthBiasClamp: 0.0, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| {arrayStride: 2320, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 1636, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm16x2', offset: 12, shaderLocation: 18}, |
| {format: 'sint32x2', offset: 620, shaderLocation: 13}, |
| {format: 'snorm16x2', offset: 1608, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'back'}, |
| }); |
| let imageBitmap5 = await createImageBitmap(offscreenCanvas3); |
| let renderBundle39 = renderBundleEncoder27.finish({label: '\u1cc9\ucded\uc0ba'}); |
| try { |
| renderBundleEncoder34.setBindGroup(6, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(620748452, 72577601, 141087103, 116028788); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer8, 36648); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(5, buffer3, 12980, 8178); |
| } catch {} |
| try { |
| commandEncoder23.resolveQuerySet(querySet12, 1888, 612, buffer10, 63488); |
| } catch {} |
| let commandEncoder74 = device0.createCommandEncoder({label: '\u3f95\u0775\u2c8d\u{1fed6}\u05ed\uceee'}); |
| let textureView82 = texture18.createView({label: '\uced4\u5adf', baseArrayLayer: 0}); |
| try { |
| computePassEncoder19.setBindGroup(6, bindGroup9, new Uint32Array(6108), 2434, 0); |
| } catch {} |
| try { |
| renderBundleEncoder32.setVertexBuffer(5, buffer8, 95228, 63557); |
| } catch {} |
| try { |
| commandEncoder69.copyBufferToBuffer(buffer12, 66664, buffer0, 128484, 22864); |
| dissociateBuffer(device0, buffer12); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas5, |
| origin: { x: 7, y: 11 }, |
| flipY: true, |
| }, { |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext7 = offscreenCanvas13.getContext('webgpu'); |
| let img8 = await imageWithData(106, 76, '#2b2ea123', '#8d53eca3'); |
| let videoFrame7 = new VideoFrame(offscreenCanvas2, {timestamp: 0}); |
| let texture65 = device0.createTexture({ |
| label: '\u9783\u{1f9a3}\ub2bf\u7243', |
| size: {width: 176}, |
| dimension: '1d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder28.setBindGroup(5, bindGroup0, new Uint32Array(3468), 2063, 0); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(1216105858); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer11, 13932); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline19); |
| } catch {} |
| gc(); |
| let shaderModule12 = device0.createShaderModule({ |
| label: '\u086d\u{1fe5b}\u7c99\u{1f837}\ucdd1\ud745\u1ccf\u07e1\u0171\ua082\uae78', |
| code: `@group(2) @binding(1530) |
| var<storage, read_write> n4: array<u32>; |
| @group(0) @binding(6255) |
| var<storage, read_write> n5: array<u32>; |
| @group(1) @binding(2593) |
| var<storage, read_write> parameter5: array<u32>; |
| |
| @compute @workgroup_size(1, 3, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S10 { |
| @location(58) f0: vec2<i32>, |
| @location(74) f1: vec3<f16>, |
| @location(76) f2: vec4<u32>, |
| @builtin(sample_index) f3: u32, |
| @location(36) f4: f32, |
| @location(43) f5: vec4<i32>, |
| @location(50) f6: vec2<f32>, |
| @location(80) f7: vec2<f32>, |
| @location(20) f8: vec4<f32>, |
| @location(59) f9: f32, |
| @location(44) f10: vec4<i32>, |
| @location(51) f11: vec2<f32>, |
| @location(73) f12: vec3<i32> |
| } |
| struct FragmentOutput0 { |
| @location(2) f0: u32, |
| @location(3) f1: vec4<i32>, |
| @location(0) f2: vec4<u32>, |
| @location(4) f3: vec4<f32>, |
| @location(1) f4: vec4<i32> |
| } |
| |
| @fragment |
| fn fragment0(a0: S10, @location(38) a1: vec2<u32>, @location(34) a2: u32, @location(35) a3: vec3<u32>, @builtin(sample_mask) a4: u32, @location(41) a5: f32, @location(8) a6: f32, @location(17) a7: i32, @location(63) a8: vec3<f16>, @location(67) a9: vec4<f32>, @location(12) a10: f32, @location(69) a11: f16, @location(31) a12: vec2<f16>, @location(75) a13: vec4<i32>, @location(0) a14: vec2<u32>, @location(26) a15: vec3<f16>, @location(9) a16: vec3<i32>, @location(65) a17: u32, @location(48) a18: vec4<f32>, @location(61) a19: vec3<i32>, @location(30) a20: u32, @location(39) a21: vec4<f16>, @location(7) a22: vec3<f16>, @location(64) a23: f16, @location(3) a24: vec3<f32>, @location(21) a25: vec3<f32>, @builtin(position) a26: vec4<f32>, @builtin(front_facing) a27: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S9 { |
| @location(7) f0: vec3<f16>, |
| @location(2) f1: vec4<f32>, |
| @location(1) f2: vec4<u32>, |
| @location(6) f3: vec4<f32>, |
| @builtin(vertex_index) f4: u32, |
| @location(9) f5: vec2<f32>, |
| @location(0) f6: vec2<u32>, |
| @location(17) f7: vec4<f32>, |
| @location(19) f8: f32, |
| @location(23) f9: u32, |
| @location(18) f10: vec3<f16>, |
| @location(21) f11: vec3<u32>, |
| @location(4) f12: vec2<f16>, |
| @location(3) f13: f32, |
| @builtin(instance_index) f14: u32, |
| @location(16) f15: vec4<f32>, |
| @location(20) f16: u32, |
| @location(22) f17: vec3<i32>, |
| @location(12) f18: u32, |
| @location(10) f19: vec4<f16>, |
| @location(11) f20: vec3<u32> |
| } |
| struct VertexOutput0 { |
| @location(26) f112: vec3<f16>, |
| @location(17) f113: i32, |
| @location(69) f114: f16, |
| @location(80) f115: vec2<f32>, |
| @location(59) f116: f32, |
| @location(58) f117: vec2<i32>, |
| @location(67) f118: vec4<f32>, |
| @location(36) f119: f32, |
| @location(50) f120: vec2<f32>, |
| @location(20) f121: vec4<f32>, |
| @location(3) f122: vec3<f32>, |
| @location(76) f123: vec4<u32>, |
| @location(64) f124: f16, |
| @location(7) f125: vec3<f16>, |
| @location(8) f126: f32, |
| @location(12) f127: f32, |
| @location(34) f128: u32, |
| @location(35) f129: vec3<u32>, |
| @location(0) f130: vec2<u32>, |
| @location(38) f131: vec2<u32>, |
| @location(43) f132: vec4<i32>, |
| @location(39) f133: vec4<f16>, |
| @location(75) f134: vec4<i32>, |
| @location(31) f135: vec2<f16>, |
| @location(41) f136: f32, |
| @location(44) f137: vec4<i32>, |
| @location(48) f138: vec4<f32>, |
| @location(51) f139: vec2<f32>, |
| @location(73) f140: vec3<i32>, |
| @location(74) f141: vec3<f16>, |
| @location(30) f142: u32, |
| @builtin(position) f143: vec4<f32>, |
| @location(9) f144: vec3<i32>, |
| @location(65) f145: u32, |
| @location(63) f146: vec3<f16>, |
| @location(61) f147: vec3<i32>, |
| @location(21) f148: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(15) a0: u32, @location(13) a1: vec3<f32>, @location(14) a2: vec3<i32>, a3: S9, @location(8) a4: f16) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| let commandEncoder75 = device0.createCommandEncoder({label: '\ua60d\u87fe\u04ea\uf675\u{1f861}\u3d9b\u09de\u16e9\u9257'}); |
| let querySet27 = device0.createQuerySet({label: '\ud6be\u6421\u014e\u92c3\u1710\u907e', type: 'occlusion', count: 294}); |
| let renderBundleEncoder35 = device0.createRenderBundleEncoder({ |
| label: '\ubc93\u01fd\u{1f90d}\ua8c8', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer11, 13528); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToTexture({ |
| /* bytesInLastRow: 3088 widthInBlocks: 772 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 18496 */ |
| offset: 18496, |
| bytesPerRow: 3328, |
| buffer: buffer5, |
| }, { |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 170, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 772, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| commandEncoder43.resolveQuerySet(querySet10, 1135, 601, buffer10, 59904); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let offscreenCanvas14 = new OffscreenCanvas(803, 923); |
| try { |
| offscreenCanvas14.getContext('webgl2'); |
| } catch {} |
| let shaderModule13 = device0.createShaderModule({ |
| label: '\u{1fd13}\ud7dc\ud29d\u4568\udda2\u05fa\u088c\u0d5e\ue18f\ua085', |
| code: `@group(1) @binding(2593) |
| var<storage, read_write> field4: array<u32>; |
| @group(0) @binding(3816) |
| var<storage, read_write> n6: array<u32>; |
| @group(1) @binding(6303) |
| var<storage, read_write> parameter6: array<u32>; |
| @group(0) @binding(4504) |
| var<storage, read_write> n7: array<u32>; |
| @group(0) @binding(3513) |
| var<storage, read_write> field5: array<u32>; |
| |
| @compute @workgroup_size(4, 2, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(4) f0: vec4<f32>, |
| @location(1) f1: vec4<i32>, |
| @location(0) f2: vec3<u32>, |
| @location(3) f3: vec2<i32>, |
| @location(2) f4: vec3<u32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_mask) a0: u32, @builtin(position) a1: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S11 { |
| @location(7) f0: vec2<f16>, |
| @location(4) f1: vec4<i32>, |
| @location(13) f2: vec3<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(17) a0: vec4<u32>, @location(14) a1: vec2<u32>, @location(22) a2: vec3<i32>, a3: S11, @location(15) a4: vec2<f32>, @location(21) a5: vec2<u32>, @location(9) a6: vec3<u32>, @location(19) a7: u32, @location(1) a8: vec2<u32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroupLayout19 = device0.createBindGroupLayout({label: '\u63bc\ubc4e', entries: []}); |
| try { |
| computePassEncoder0.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup21, new Uint32Array(8905), 7473, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer1, 28560); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer11, 'uint16', 18216, 67519); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToBuffer({ |
| texture: texture61, |
| mipLevel: 1, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 7580 */ |
| offset: 7580, |
| bytesPerRow: 256, |
| buffer: buffer1, |
| }, {width: 4, height: 5, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder68.resolveQuerySet(querySet20, 7, 163, buffer10, 37120); |
| } catch {} |
| try { |
| renderBundleEncoder12.insertDebugMarker('\ub869'); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({ |
| label: '\u0b86\u{1fd55}\u{1fd82}\u161f', |
| layout: bindGroupLayout1, |
| entries: [{binding: 1494, resource: sampler3}], |
| }); |
| let texture66 = device0.createTexture({ |
| label: '\u7a7f\u0e9f\u881f\u07c3\uf371', |
| size: [298, 16, 1], |
| mipLevelCount: 3, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16uint', 'r16uint'], |
| }); |
| let textureView83 = texture53.createView({label: '\u9409\u144f\u{1fa53}\u{1f73f}\u{1fee6}\u16df\u0f1e'}); |
| let computePassEncoder29 = commandEncoder57.beginComputePass({label: '\uff97\u{1fb08}\u04c5'}); |
| let renderBundleEncoder36 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: false, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder5.draw(229561874, 392398491, 171620501, 92987112); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(315117686); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer1, 102308); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(2, buffer8); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture64, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint16Array(arrayBuffer5), /* required buffer size: 287366 */ |
| {offset: 86, bytesPerRow: 36, rowsPerImage: 105}, {width: 9, height: 0, depthOrArrayLayers: 77}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let img9 = await imageWithData(186, 182, '#3fa3d89a', '#4c5fc274'); |
| let bindGroup25 = device0.createBindGroup({ |
| label: '\uf844\u09a5\u{1f72a}\u05ee\u0b4a\u083b\u{1f9a1}\u02f7', |
| layout: bindGroupLayout7, |
| entries: [{binding: 1530, resource: externalTexture12}], |
| }); |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let querySet28 = device0.createQuerySet({ |
| label: '\u{1ff08}\u09a7\u{1f916}\u0970\u056b\uffe3\u086c\u37de\u0572\u1095', |
| type: 'occlusion', |
| count: 2952, |
| }); |
| let textureView84 = texture11.createView({label: '\u1a0e\ud322\u{1fb27}\u{1fe80}\u{1f78a}', dimension: '2d-array'}); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(788848702, 776074138, 569796759, 1133821890); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer11, 17280); |
| } catch {} |
| try { |
| renderBundleEncoder35.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(9, buffer3); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 544 widthInBlocks: 136 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 66736 */ |
| offset: 30864, |
| bytesPerRow: 768, |
| buffer: buffer4, |
| }, { |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 136, height: 47, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| try { |
| commandEncoder51.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 63, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 656 widthInBlocks: 164 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 8688 */ |
| offset: 8688, |
| buffer: buffer10, |
| }, {width: 164, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder69.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture25, |
| mipLevel: 1, |
| origin: {x: 0, y: 4, z: 12}, |
| aspect: 'all', |
| }, |
| {width: 549, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout20 = device0.createBindGroupLayout({ |
| label: '\u{1fd1d}\u{1fc59}', |
| entries: [ |
| { |
| binding: 5098, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder77 = device0.createCommandEncoder(); |
| let sampler30 = device0.createSampler({ |
| label: '\u30b9\uf89b\ub2d2\u4248\u{1f6ca}\udd3f\u3698\u30a1\u0378\u680c', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 97.54, |
| lodMaxClamp: 99.77, |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(5, bindGroup2, new Uint32Array(7747), 661, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(450139675, 782317263, 185586957, -926358288, 1031245962); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer1, 199960); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(2, buffer8); |
| } catch {} |
| let arrayBuffer7 = buffer9.getMappedRange(28368, 28); |
| try { |
| commandEncoder31.copyTextureToTexture({ |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 296, y: 23, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 176, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({label: '\ud8ee\u{1f823}\u0e75\u469b\u0937\u90a5\u{1f8c5}\u3135\u0a90\u0b60\u{1fd8f}'}); |
| let textureView85 = texture28.createView({label: '\ua1a5\u{1f69f}\u5c7a\u9f18', baseMipLevel: 3, mipLevelCount: 1}); |
| let renderBundle40 = renderBundleEncoder10.finish({}); |
| let sampler31 = device0.createSampler({ |
| label: '\u{1fb3a}\u3b6e\u04d0\u3400\u1f37\u{1fe4d}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 15.29, |
| lodMaxClamp: 76.64, |
| }); |
| try { |
| renderBundleEncoder34.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder35.setVertexBuffer(2, buffer8, 165660); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToBuffer(buffer3, 41800, buffer10, 78316, 2660); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 28416 */ |
| offset: 28416, |
| bytesPerRow: 256, |
| buffer: buffer4, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 313, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 55, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder75.resolveQuerySet(querySet10, 1702, 163, buffer10, 52480); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 55648, new Float32Array(27403), 13581, 1936); |
| } catch {} |
| let pipeline70 = device0.createRenderPipeline({ |
| label: '\uc29d\u{1f9c0}\u0858\ufef3\u5dda\u0fa5\u095e\u094b\u{1fd68}\u3b9e\u8c0a', |
| layout: 'auto', |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, { |
| format: 'rg16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'r16uint', writeMask: GPUColorWrite.RED}, {format: 'r32sint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'src'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilFront: {compare: 'greater-equal', failOp: 'zero', depthFailOp: 'zero', passOp: 'decrement-wrap'}, |
| stencilBack: {compare: 'greater', failOp: 'zero', depthFailOp: 'keep'}, |
| stencilReadMask: 4208725088, |
| depthBiasSlopeScale: 665.1810062704798, |
| depthBiasClamp: 203.21572361718387, |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 7912, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 2180, shaderLocation: 14}, |
| {format: 'float32x3', offset: 28, shaderLocation: 19}, |
| {format: 'unorm10-10-10-2', offset: 5932, shaderLocation: 15}, |
| {format: 'uint16x2', offset: 4368, shaderLocation: 8}, |
| {format: 'float32', offset: 844, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 1736, shaderLocation: 1}, |
| {format: 'snorm16x4', offset: 160, shaderLocation: 18}, |
| ], |
| }, |
| { |
| arrayStride: 17076, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 1108, shaderLocation: 22}, |
| {format: 'uint8x4', offset: 8192, shaderLocation: 21}, |
| {format: 'snorm8x2', offset: 10, shaderLocation: 9}, |
| {format: 'snorm8x4', offset: 4272, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 16520, |
| attributes: [ |
| {format: 'float32', offset: 4056, shaderLocation: 6}, |
| {format: 'unorm8x4', offset: 112, shaderLocation: 20}, |
| {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 13}, |
| {format: 'snorm16x4', offset: 1516, shaderLocation: 3}, |
| ], |
| }, |
| { |
| arrayStride: 1924, |
| stepMode: 'vertex', |
| attributes: [{format: 'unorm8x4', offset: 308, shaderLocation: 0}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let img10 = await imageWithData(292, 56, '#1dc7ee69', '#91834449'); |
| try { |
| renderBundleEncoder5.draw(717647796); |
| } catch {} |
| let arrayBuffer8 = buffer0.getMappedRange(0, 125536); |
| try { |
| commandEncoder64.copyBufferToBuffer(buffer6, 204868, buffer0, 497464, 14916); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer0); |
| } catch {} |
| try { |
| commandEncoder55.resolveQuerySet(querySet25, 287, 305, buffer10, 67072); |
| } catch {} |
| let buffer14 = device0.createBuffer({ |
| label: '\u41fc\u0dc5\u{1f60b}\u8e6c\u8f1a\ucf42\u68da\ud5f7', |
| size: 88836, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT, |
| mappedAtCreation: true, |
| }); |
| let texture67 = device0.createTexture({ |
| label: '\uda6d\u{1fdfd}\u08e0\ufcff', |
| size: {width: 1194, height: 64, depthOrArrayLayers: 656}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView86 = texture45.createView({label: '\u412a\u0894\ua7b6\u8153\u0443\u186e'}); |
| let sampler32 = device0.createSampler({ |
| label: '\u802b\u5a85\u{1ff9c}', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 61.45, |
| lodMaxClamp: 90.65, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup20); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer11, 130632); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer8, 'uint32', 78032, 77838); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 603, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture60, |
| mipLevel: 1, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 35, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder27.resolveQuerySet(querySet14, 2221, 743, buffer10, 6912); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| let pipeline71 = device0.createComputePipeline({ |
| label: '\u62db\u{1fc6b}\ucdd3', |
| layout: 'auto', |
| compute: {module: shaderModule4, entryPoint: 'compute0'}, |
| }); |
| let video9 = await videoWithData(); |
| let bindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2872, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 1149, |
| visibility: 0, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }, |
| {binding: 859, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let pipelineLayout9 = device0.createPipelineLayout({label: '\u0304\u07cd\uccab\u071f\u3199\ud103', bindGroupLayouts: [bindGroupLayout0]}); |
| let texture68 = device0.createTexture({ |
| label: '\u{1fe01}\u0aed\u80fe\u{1fa5a}\u3e1b\u0839\u{1fd44}\u{1fd90}\u6172', |
| size: [160, 20, 4], |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16uint', 'r16uint'], |
| }); |
| let textureView87 = texture14.createView({label: '\ubd37\u1012\u0d0c\u{1fbb0}\ue313\u1afa'}); |
| let externalTexture34 = device0.importExternalTexture({source: video3}); |
| try { |
| renderBundleEncoder36.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer11, 18584); |
| } catch {} |
| try { |
| renderBundleEncoder28.insertDebugMarker('\u73e2'); |
| } catch {} |
| let textureView88 = texture32.createView({label: '\u0ba5\u095b\uf0ba\u{1ff82}\ua767\u{1ff1d}', format: 'rgba8unorm-srgb'}); |
| let renderBundleEncoder37 = device0.createRenderBundleEncoder({ |
| label: '\u0c4e\uc24b\u{1fc6b}\uc268\uaf8a\u8fcf\uee5c\u2788\u151a\udd7f', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder25.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexed(292550645, 1135744198, 488250687, 353696790, 100844734); |
| } catch {} |
| try { |
| commandEncoder71.copyBufferToBuffer(buffer8, 62552, buffer7, 3760, 624); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| let pipeline72 = device0.createRenderPipeline({ |
| layout: pipelineLayout9, |
| multisample: {mask: 0xb790eb4a}, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.BLUE}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, { |
| format: 'r16uint', |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'r32sint'}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'src', dstFactor: 'src'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater-equal', |
| stencilFront: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'keep', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'less', depthFailOp: 'zero', passOp: 'increment-wrap'}, |
| stencilReadMask: 515786769, |
| stencilWriteMask: 1637728573, |
| depthBias: -197295034, |
| depthBiasSlopeScale: 83.22962205333849, |
| depthBiasClamp: 641.5379644370298, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [{arrayStride: 12032, attributes: [{format: 'unorm16x4', offset: 5696, shaderLocation: 2}]}], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', unclippedDepth: true}, |
| }); |
| let gpuCanvasContext8 = offscreenCanvas11.getContext('webgpu'); |
| let renderBundleEncoder38 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: true, |
| }); |
| let renderBundle41 = renderBundleEncoder13.finish({label: '\u4326\udf8b\u9f0a'}); |
| let sampler33 = device0.createSampler({ |
| label: '\u0785\u956e\u906d\u84de\u367f\u0265\u0ab0\u{1fd7a}\u7bba\u8147', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 50.25, |
| lodMaxClamp: 68.26, |
| }); |
| try { |
| renderBundleEncoder15.setPipeline(pipeline65); |
| } catch {} |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer8, 152140, buffer14, 39732, 1268); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer14); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 106, y: 66 }, |
| flipY: false, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame8 = new VideoFrame(video9, {timestamp: 0}); |
| let textureView89 = texture42.createView({ |
| label: '\u02e3\u234f\u9616\u787e\u0343\uafc2\ude9c\u0f23\u008c\u411f\u0fbd', |
| baseMipLevel: 1, |
| mipLevelCount: 2, |
| }); |
| let sampler34 = device0.createSampler({ |
| label: '\u{1f946}\ue080\u{1f6c7}\u7429\u0dd8\u425b\u016d', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 74.73, |
| }); |
| try { |
| renderBundleEncoder37.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToTexture({ |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 16, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline73 = await promise22; |
| offscreenCanvas7.height = 219; |
| let promise25 = adapter0.requestAdapterInfo(); |
| let textureView90 = texture67.createView({label: '\ue606\u{1f8bc}\uffd9\u0de4\u0254\u{1ff09}', mipLevelCount: 1}); |
| let computePassEncoder30 = commandEncoder39.beginComputePass(); |
| let renderBundle42 = renderBundleEncoder9.finish({label: '\u191a\u0f08\u6325'}); |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer11, 14924); |
| } catch {} |
| try { |
| commandEncoder58.copyBufferToTexture({ |
| /* bytesInLastRow: 172 widthInBlocks: 86 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 12262 */ |
| offset: 12262, |
| bytesPerRow: 256, |
| buffer: buffer8, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 215, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 86, height: 75, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer8); |
| } catch {} |
| try { |
| commandEncoder74.copyTextureToTexture({ |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 291, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 80, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 80600, new DataView(new ArrayBuffer(33885)), 3504, 880); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture44, |
| mipLevel: 1, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8ClampedArray(new ArrayBuffer(80)), /* required buffer size: 171513 */ |
| {offset: 73, bytesPerRow: 400, rowsPerImage: 210}, {width: 120, height: 9, depthOrArrayLayers: 3}); |
| } catch {} |
| let pipeline74 = device0.createRenderPipeline({ |
| label: '\uf699\uf586\uad50\uac9f\u{1fdc5}\u8aca\uf3fa\u0951', |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16sint'}, {format: 'r16uint', writeMask: 0}, {format: 'r32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'src', dstFactor: 'one-minus-dst'}, |
| }, |
| writeMask: GPUColorWrite.GREEN, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilFront: {failOp: 'increment-clamp', depthFailOp: 'invert', passOp: 'replace'}, |
| stencilBack: {compare: 'less', failOp: 'replace', depthFailOp: 'increment-wrap', passOp: 'keep'}, |
| stencilReadMask: 2719145049, |
| stencilWriteMask: 493167115, |
| depthBias: -2008653279, |
| depthBiasSlopeScale: 753.9374082333197, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 12284, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm8x4', offset: 6844, shaderLocation: 6}, |
| {format: 'unorm16x4', offset: 216, shaderLocation: 18}, |
| {format: 'sint16x2', offset: 4044, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let commandEncoder79 = device0.createCommandEncoder({label: '\u0ac7\u92ea\u07ec\u0745\u{1f770}\u0977\udcbb\ubaf0'}); |
| let querySet29 = device0.createQuerySet({ |
| label: '\u9a69\u0a4c\u0685\uec1c\u{1f89e}\u1591\ub2af\u962f\u{1f6be}\u{1ff10}', |
| type: 'occlusion', |
| count: 3010, |
| }); |
| let externalTexture35 = device0.importExternalTexture({label: '\u{1fb53}\u{1fef6}\u0b93\ub536\u30ee', source: video2, colorSpace: 'display-p3'}); |
| try { |
| renderBundleEncoder5.drawIndexed(342096521); |
| } catch {} |
| try { |
| commandEncoder4.copyBufferToBuffer(buffer2, 581464, buffer14, 7216, 16072); |
| dissociateBuffer(device0, buffer2); |
| dissociateBuffer(device0, buffer14); |
| } catch {} |
| try { |
| commandEncoder52.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture67, |
| mipLevel: 2, |
| origin: {x: 34, y: 7, z: 5}, |
| aspect: 'all', |
| }, |
| {width: 175, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder41.clearBuffer(buffer14); |
| dissociateBuffer(device0, buffer14); |
| } catch {} |
| try { |
| renderBundleEncoder22.insertDebugMarker('\u52cd'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 2, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint16Array(arrayBuffer8), /* required buffer size: 397 */ |
| {offset: 397, bytesPerRow: 321}, {width: 73, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline75 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule13, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r16uint'}, { |
| format: 'r32sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }, {format: 'rgba8unorm-srgb', writeMask: 0}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilFront: {compare: 'less-equal', failOp: 'decrement-clamp', depthFailOp: 'replace', passOp: 'zero'}, |
| stencilBack: {compare: 'never', failOp: 'increment-wrap', depthFailOp: 'increment-wrap', passOp: 'zero'}, |
| stencilReadMask: 2932303587, |
| stencilWriteMask: 1415785312, |
| depthBias: 1523325914, |
| depthBiasSlopeScale: 4.140863212310592, |
| depthBiasClamp: 580.1298049438051, |
| }, |
| vertex: { |
| module: shaderModule13, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x2', offset: 46472, shaderLocation: 4}, |
| {format: 'uint32x3', offset: 28792, shaderLocation: 9}, |
| {format: 'float32', offset: 28484, shaderLocation: 7}, |
| {format: 'uint32x2', offset: 8844, shaderLocation: 21}, |
| {format: 'sint16x4', offset: 18200, shaderLocation: 13}, |
| {format: 'uint8x2', offset: 6304, shaderLocation: 19}, |
| {format: 'uint16x2', offset: 17256, shaderLocation: 17}, |
| ], |
| }, |
| { |
| arrayStride: 5788, |
| attributes: [ |
| {format: 'uint16x4', offset: 488, shaderLocation: 14}, |
| {format: 'uint32', offset: 2668, shaderLocation: 1}, |
| {format: 'sint32x4', offset: 860, shaderLocation: 22}, |
| ], |
| }, |
| {arrayStride: 44360, attributes: []}, |
| {arrayStride: 64488, stepMode: 'instance', attributes: []}, |
| {arrayStride: 18140, stepMode: 'instance', attributes: []}, |
| {arrayStride: 8408, stepMode: 'instance', attributes: []}, |
| {arrayStride: 0, attributes: [{format: 'float16x2', offset: 8976, shaderLocation: 15}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'ccw', unclippedDepth: true}, |
| }); |
| document.body.prepend(canvas0); |
| let textureView91 = texture1.createView({label: '\u6d0b\ua18c\u{1f807}\uf140\u{1f799}\u269e\u0fb5\u330f\ub483\ud7e5\u08ea'}); |
| try { |
| computePassEncoder17.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(4, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer1, 134828); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer8, 'uint32'); |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await buffer13.mapAsync(GPUMapMode.WRITE, 102400, 372); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToBuffer(buffer6, 178088, buffer1, 130852, 69456); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder72.copyBufferToTexture({ |
| /* bytesInLastRow: 132 widthInBlocks: 66 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 15522 */ |
| offset: 14622, |
| bytesPerRow: 256, |
| buffer: buffer6, |
| }, { |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 19, y: 8, z: 0}, |
| aspect: 'all', |
| }, {width: 66, height: 4, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 7, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint32Array(arrayBuffer2), /* required buffer size: 848 */ |
| {offset: 848}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 597, height: 32, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video9, |
| origin: { x: 4, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture49, |
| mipLevel: 1, |
| origin: {x: 16, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder80 = device0.createCommandEncoder({label: '\ufc16\u{1fb59}\u{1fd45}\u840e\u{1fe09}\uc69a\u05b3\u0ac9\u9c07'}); |
| let textureView92 = texture15.createView({label: '\u{1fa11}\u25e7\u98f6\u747b\u{1fce6}\u5c60\u24e6', mipLevelCount: 1}); |
| let renderBundleEncoder39 = device0.createRenderBundleEncoder({ |
| label: '\udde2\u0ed5\u8f19\u{1f95b}', |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| }); |
| let externalTexture36 = device0.importExternalTexture({label: '\u53cb\u4bba\ua4b1\u{1f6dc}\u{1f641}\u03a9', source: video7, colorSpace: 'display-p3'}); |
| try { |
| renderBundleEncoder8.drawIndirect(buffer8, 23108); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline39); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(4, buffer3, 0); |
| } catch {} |
| try { |
| commandEncoder68.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 10, y: 34, z: 14}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 102, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 56, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| offscreenCanvas12.getContext('webgpu'); |
| } catch {} |
| let buffer15 = device0.createBuffer({ |
| label: '\ufc4a\u4257\u2c3c\u0c64\u{1f763}\u{1f980}\u{1f909}\u{1fcd3}\u9f31', |
| size: 579385, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT, |
| }); |
| let renderBundleEncoder40 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8uint', 'rg16sint', 'r16uint', 'r32sint', 'rgba8unorm-srgb'], |
| stencilReadOnly: false, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(6, bindGroup22, new Uint32Array(2387), 2367, 0); |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(1037672419, 720445798); |
| } catch {} |
| try { |
| commandEncoder14.copyTextureToBuffer({ |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 426 widthInBlocks: 213 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 21436 */ |
| offset: 17938, |
| bytesPerRow: 512, |
| buffer: buffer10, |
| }, {width: 213, height: 7, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 58196, new Int16Array(62403), 22530, 3600); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let shaderModule14 = device0.createShaderModule({ |
| label: '\uf9c2\u{1ff31}', |
| code: `@group(1) @binding(1530) |
| var<storage, read_write> local8: array<u32>; |
| @group(0) @binding(1530) |
| var<storage, read_write> global9: array<u32>; |
| |
| @compute @workgroup_size(6, 2, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S13 { |
| @builtin(position) f0: vec4<f32>, |
| @builtin(sample_mask) f1: u32 |
| } |
| struct FragmentOutput0 { |
| @location(2) f0: u32, |
| @location(0) f1: vec3<u32>, |
| @location(3) f2: vec2<i32>, |
| @location(4) f3: vec4<f32>, |
| @location(1) f4: vec4<i32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, a1: S13, @builtin(sample_index) a2: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S12 { |
| @location(14) f0: vec2<u32>, |
| @location(0) f1: vec4<u32>, |
| @location(8) f2: i32, |
| @location(15) f3: vec2<u32>, |
| @location(17) f4: vec2<f16>, |
| @location(1) f5: vec3<f32>, |
| @location(7) f6: i32, |
| @location(9) f7: vec2<f32>, |
| @location(22) f8: vec4<i32>, |
| @location(6) f9: vec3<f16>, |
| @location(12) f10: vec2<i32>, |
| @location(5) f11: vec4<f16> |
| } |
| |
| @vertex |
| fn vertex0(@location(21) a0: vec4<u32>, @location(13) a1: vec4<i32>, a2: S12, @location(18) a3: i32, @location(10) a4: vec3<f32>, @location(3) a5: vec2<i32>, @location(16) a6: vec2<f32>, @location(20) a7: vec3<u32>, @location(19) a8: vec2<f32>, @location(2) a9: i32, @location(11) a10: vec3<f16>, @location(4) a11: vec2<u32>, @location(23) a12: vec2<u32>, @builtin(instance_index) a13: u32, @builtin(vertex_index) a14: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder81 = device0.createCommandEncoder({label: '\uafb9\u{1f793}\u276b\u{1f8a1}\u2aed\u6f22'}); |
| let querySet30 = device0.createQuerySet({label: '\uddf1\u604a\u6e68\u0441\u030d\u1bd0\u7e95\u{1fd03}\u{1faa8}', type: 'occlusion', count: 1790}); |
| let renderBundle43 = renderBundleEncoder34.finish({}); |
| let sampler35 = device0.createSampler({ |
| label: '\u{1f8aa}\ua712\u{1fc2f}', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 65.75, |
| lodMaxClamp: 80.35, |
| }); |
| try { |
| commandEncoder72.copyBufferToTexture({ |
| /* bytesInLastRow: 812 widthInBlocks: 203 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 47808 */ |
| offset: 47808, |
| bytesPerRow: 1024, |
| rowsPerImage: 153, |
| buffer: buffer12, |
| }, { |
| texture: texture35, |
| mipLevel: 1, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 203, height: 28, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 300, height: 48, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img8, |
| origin: { x: 7, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 44, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer23 = commandEncoder67.finish(); |
| let renderBundle44 = renderBundleEncoder33.finish(); |
| let sampler36 = device0.createSampler({ |
| label: '\u07a5\u6241\u0d86\u07f2\u{1ffaf}\u7e5c\u062d\u3e77\u39f5', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 12.76, |
| lodMaxClamp: 91.54, |
| }); |
| try { |
| renderBundleEncoder12.setPipeline(pipeline19); |
| } catch {} |
| try { |
| buffer10.destroy(); |
| } catch {} |
| try { |
| commandEncoder72.copyBufferToBuffer(buffer8, 10868, buffer1, 253996, 96060); |
| dissociateBuffer(device0, buffer8); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder14.copyTextureToBuffer({ |
| texture: texture42, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 16676 */ |
| offset: 16676, |
| bytesPerRow: 256, |
| buffer: buffer1, |
| }, {width: 5, height: 3, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToTexture({ |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 8, y: 1, z: 86}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 109, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder55.clearBuffer(buffer7, 1236, 4312); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 4936, new DataView(new ArrayBuffer(52800)), 9656, 16336); |
| } catch {} |
| let imageBitmap6 = await createImageBitmap(videoFrame6); |
| let pipelineLayout10 = device0.createPipelineLayout({ |
| label: '\uf929\u99fd', |
| bindGroupLayouts: [bindGroupLayout11, bindGroupLayout15, bindGroupLayout4, bindGroupLayout5, bindGroupLayout5], |
| }); |
| let buffer16 = device0.createBuffer({ |
| label: '\u75d5\u0794\u6fa0\u99ff\u0733', |
| size: 169596, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: true, |
| }); |
| let textureView93 = texture17.createView({label: '\uf126\u01f5\u{1fae1}\u03ce\u5d6e\uedb3\u0044\ua802', dimension: '2d-array', baseMipLevel: 4}); |
| let externalTexture37 = device0.importExternalTexture({label: '\u{1fc0a}\u0d89\udce6\ub3cf', source: video5, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder3.setBindGroup(4, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder37.setBindGroup(1, bindGroup6, new Uint32Array(8479), 5282, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndexedIndirect(buffer16, 18236); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer11, 'uint32', 61112, 48822); |
| } catch {} |
| try { |
| commandEncoder72.copyTextureToTexture({ |
| texture: texture0, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 727}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture0, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 40, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder81.clearBuffer(buffer16, 135012); |
| dissociateBuffer(device0, buffer16); |
| } catch {} |
| let pipeline76 = device0.createComputePipeline({ |
| label: '\u0439\u06bf\u{1fa4f}', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule5, entryPoint: 'compute0'}, |
| }); |
| let imageData6 = new ImageData(244, 204); |
| let bindGroupLayout22 = device0.createBindGroupLayout({ |
| label: '\u0fd1\u5c7c\u40a4\u7317\u0068\u07b1\u4af0\u09ce', |
| entries: [ |
| { |
| binding: 5145, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 4881, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let buffer17 = device0.createBuffer({size: 148800, usage: GPUBufferUsage.VERTEX}); |
| try { |
| renderBundleEncoder14.setBindGroup(6, bindGroup22); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer8, 8496); |
| } catch {} |
| try { |
| await buffer2.mapAsync(GPUMapMode.WRITE, 283800, 68980); |
| } catch {} |
| try { |
| commandEncoder69.resolveQuerySet(querySet22, 3271, 21, buffer10, 31744); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, new DataView(arrayBuffer2), /* required buffer size: 53958 */ |
| {offset: 412, bytesPerRow: 558}, {width: 134, height: 96, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.prepend(video2); |
| let offscreenCanvas15 = new OffscreenCanvas(926, 177); |
| let imageData7 = new ImageData(120, 148); |
| let bindGroupLayout23 = device0.createBindGroupLayout({ |
| label: '\ue638\uaf96\uc57b\u0e38\u7aff\u05ee', |
| entries: [ |
| { |
| binding: 1809, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 3954, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 647, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView94 = texture66.createView({label: '\u325d\u0deb\u0618\u02db\u9153\u7f3a', dimension: '2d-array', baseMipLevel: 1}); |
| let sampler37 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 83.56, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(6, bindGroup0, []); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer14, 1592); |
| } catch {} |
| try { |
| commandEncoder33.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 11760 */ |
| offset: 11760, |
| rowsPerImage: 129, |
| buffer: buffer10, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| commandEncoder68.clearBuffer(buffer14); |
| dissociateBuffer(device0, buffer14); |
| } catch {} |
| try { |
| commandEncoder53.resolveQuerySet(querySet0, 486, 136, buffer10, 40704); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer23]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas13, |
| origin: { x: 47, y: 315 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline77 = device0.createComputePipeline({ |
| label: '\u0211\u1d3d', |
| layout: pipelineLayout8, |
| compute: {module: shaderModule14, entryPoint: 'compute0'}, |
| }); |
| offscreenCanvas9.width = 1568; |
| let bindGroup26 = device0.createBindGroup({ |
| label: '\u48b3\uaf2c\u{1f617}\u{1f8e6}\u5a27\u{1f99a}\u{1f675}\u{1f740}', |
| layout: bindGroupLayout19, |
| entries: [], |
| }); |
| try { |
| renderBundleEncoder40.setBindGroup(5, bindGroup7, new Uint32Array(7569), 1999, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.draw(1229026211, 456149075, 978386523, 1188072787); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(81622257, 847120194, 474473385); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 42, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1700 widthInBlocks: 425 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 17820 */ |
| offset: 17820, |
| buffer: buffer10, |
| }, {width: 425, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 8, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 672 */ |
| {offset: 668}, {width: 2, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let renderBundle45 = renderBundleEncoder37.finish({label: '\u4188\u0d9c'}); |
| let sampler38 = device0.createSampler({ |
| label: '\u845d\ue159\u0ef3\u0181\ua50c\uc5e2\u1d80\u{1fe61}\u{1fb6a}\uea52\u01ac', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 91.17, |
| lodMaxClamp: 92.41, |
| maxAnisotropy: 9, |
| }); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToBuffer(buffer4, 118328, buffer14, 21368, 47420); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer14); |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let commandBuffer24 = commandEncoder81.finish({label: '\u0a4c\u{1fe13}\u0d94\ufd2f'}); |
| try { |
| renderBundleEncoder5.drawIndirect(buffer1, 161956); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(10, buffer3, 6140, 28680); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToBuffer({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 51792 */ |
| offset: 51792, |
| rowsPerImage: 254, |
| buffer: buffer1, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder73.clearBuffer(buffer16, 113436, 12048); |
| dissociateBuffer(device0, buffer16); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame8.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> |
| |
