| <!-- webkit-test-runner [ dumpJSConsoleLogInStdErr=true ] --> |
| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script id="shared"> |
| const log = console.log; |
| |
| async function gc() { |
| await 0; |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUComputePassEncoder} computePassEncoder |
| */ |
| function clearResourceUsages(device, computePassEncoder) { |
| let code = `@compute @workgroup_size(1) fn c() {}`; |
| let module = device.createShaderModule({code}); |
| computePassEncoder.setPipeline(device.createComputePipeline( |
| { |
| layout: 'auto', |
| compute: {module}, |
| })); |
| computePassEncoder.dispatchWorkgroups(1); |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| const videoUrls = [ |
| |
| ]; |
| |
| /** |
| * @param {number} index |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData(index) { |
| let video = document.createElement('video'); |
| video.src = videoUrls[index % videoUrls.length]; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| /** |
| * @param {string} payload |
| * @returns {string} |
| */ |
| function toBlobUrl(payload) { |
| let blob = new Blob([payload], {type: 'text/javascript'}); |
| return URL.createObjectURL(blob); |
| } |
| </script> |
| <script> |
| globalThis.testRunner?.waitUntilDone(); |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter(); |
| let adapter1 = await navigator.gpu.requestAdapter(); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'indirect-first-instance', |
| 'timestamp-query', |
| 'depth-clip-control', |
| 'texture-compression-etc2', |
| 'depth32float-stencil8', |
| 'bgra8unorm-storage', |
| 'rg11b10ufloat-renderable', |
| 'float16-renderable', |
| 'float32-blendable', |
| 'float32-renderable', |
| 'shader-f16', |
| 'texture-compression-astc', |
| ], |
| requiredLimits: { |
| maxBindGroups: 4, |
| maxInterStageShaderComponents: 64, |
| maxStorageBufferBindingSize: 183447130, |
| maxTextureDimension2D: 8192, |
| maxUniformBufferBindingSize: 114958729, |
| maxVertexBufferArrayStride: 2048, |
| minStorageBufferOffsetAlignment: 256, |
| }, |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let texture0 = device0.createTexture({ |
| size: {width: 16, height: 16, depthOrArrayLayers: 27}, |
| format: 'etc2-rgb8a1unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let textureView0 = texture0.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 96.63, |
| }); |
| let offscreenCanvas0 = new OffscreenCanvas(176, 353); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let texture1 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 61}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView1 = texture1.createView({mipLevelCount: 1}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true}); |
| try { |
| renderBundleEncoder0.insertDebugMarker('\ue2cc'); |
| } catch {} |
| let buffer0 = device0.createBuffer({size: 216, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu'); |
| let buffer1 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture2 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 243}, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer1, 'uint32', 60, 15); |
| } catch {} |
| let buffer2 = device0.createBuffer({size: 168, usage: GPUBufferUsage.VERTEX}); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let computePassEncoder0 = commandEncoder1.beginComputePass(); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer1, 'uint32', 88, 41); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(5, buffer2, 0); |
| } catch {} |
| let videoFrame0 = new VideoFrame(offscreenCanvas0, {timestamp: 0}); |
| let buffer3 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_DST}); |
| let texture3 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 14}, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture4 = device0.createTexture({size: [848], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView2 = texture1.createView({mipLevelCount: 1}); |
| let computePassEncoder1 = commandEncoder2.beginComputePass(); |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Uint32Array(20805).map((_, i) => i * 9), 1394, 0); |
| } catch {} |
| let device1 = await adapter1.requestDevice({requiredFeatures: ['shader-f16']}); |
| let texture5 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 38}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture6 = device0.createTexture({ |
| size: [3395, 1, 1], |
| mipLevelCount: 3, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView3 = texture5.createView({baseArrayLayer: 16, arrayLayerCount: 2}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({label: '\u{1f7f0}\u878a\u0df7\u{1fa5b}\ua5b7\u9601', colorFormats: ['rgba16float'], sampleCount: 4}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer1, 'uint16', 2, 83); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12, new Float32Array(6180).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.935)), 792, 0); |
| } catch {} |
| let texture7 = device0.createTexture({ |
| size: {width: 16}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView4 = texture1.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer2, 0, 30); |
| } catch {} |
| try { |
| commandEncoder3.insertDebugMarker('\u{1f60d}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 0, new Float32Array(1575).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.546)), 269, 0); |
| } catch {} |
| try { |
| adapter1.label = '\u{1fcbf}\u{1fde5}\u0b24\u16eb\u9e35\udf29\u73be'; |
| } catch {} |
| let textureView5 = texture7.createView({dimension: '1d', arrayLayerCount: 1}); |
| let texture8 = device0.createTexture({ |
| size: [16, 16, 27], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true}); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false }, |
| }, |
| {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let textureView6 = texture3.createView({arrayLayerCount: 6}); |
| let sampler1 = device0.createSampler({addressModeV: 'mirror-repeat', maxAnisotropy: 1}); |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 16, new Uint16Array(22484).map((_, i) => i + 10), 4712, 8); |
| } catch {} |
| offscreenCanvas0.height = 425; |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let buffer4 = device0.createBuffer({size: 78, usage: GPUBufferUsage.INDEX}); |
| let texture9 = device0.createTexture({ |
| size: [424, 1, 101], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture10 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder2 = commandEncoder3.beginComputePass(); |
| try { |
| renderBundleEncoder0.setVertexBuffer(6, buffer2, 0, 9); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 0, new Uint32Array(24467).map((_, i) => i * 4), 1235, 0); |
| } catch {} |
| offscreenCanvas0.height = 652; |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let texture11 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 26}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder3 = commandEncoder5.beginComputePass(); |
| try { |
| commandEncoder4.copyBufferToBuffer(buffer0, 0, buffer3, 8, 12); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| globalThis.someLabel = device1.label; |
| } catch {} |
| let buffer5 = device1.createBuffer({size: 180, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false }, |
| }, |
| {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let buffer6 = device0.createBuffer({size: 412, usage: GPUBufferUsage.MAP_WRITE}); |
| let sampler2 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 85.14, |
| maxAnisotropy: 1, |
| }); |
| let computePassEncoder4 = commandEncoder0.beginComputePass(); |
| let texture12 = device0.createTexture({ |
| size: [4, 712, 1], |
| mipLevelCount: 2, |
| format: 'astc-4x4-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture13 = device0.createTexture({ |
| size: [848, 1, 40], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView7 = texture8.createView({dimension: '2d', baseArrayLayer: 2}); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture14 = device0.createTexture({ |
| size: [424], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture15 = device0.createTexture({ |
| size: [1, 178, 4], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView8 = texture2.createView({}); |
| let buffer7 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let texture16 = device0.createTexture({ |
| size: [1, 178, 14], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture17 = device0.createTexture({ |
| size: {width: 2, height: 356, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder5 = commandEncoder4.beginComputePass(); |
| let sampler3 = device1.createSampler({addressModeV: 'clamp-to-edge', minFilter: 'linear', lodMinClamp: 47.27, lodMaxClamp: 68.63}); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout3 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture18 = device1.createTexture({ |
| size: [102, 1, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder6 = device0.createCommandEncoder(); |
| let textureView9 = texture11.createView({arrayLayerCount: 3}); |
| let textureView10 = texture5.createView({dimension: '2d-array', arrayLayerCount: 3}); |
| try { |
| commandEncoder6.copyBufferToBuffer(buffer7, 28, buffer3, 0, 0); |
| } catch {} |
| try { |
| commandEncoder6.clearBuffer(buffer7); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T0 { |
| @size(16) f0: array<atomic<i32>, 1>, |
| } |
| |
| var<workgroup> vw0: atomic<u32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T3 { |
| @align(8) f0: array<u32>, |
| } |
| |
| struct ComputeInput2 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| var<workgroup> vw1: array<atomic<u32>, 1>; |
| |
| struct T4 { |
| @size(192) f0: T1, |
| @size(800) f1: atomic<i32>, |
| } |
| |
| struct ComputeInput1 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @group(0) @binding(0) var sam0: sampler; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn0(a0: sampler) -> vec2u { |
| var out: vec2u; |
| var vf0: vec3f = quantizeToF16(vec3f(unconst_f32(-0.1505e-12), unconst_f32(0.04325e-19), unconst_f32(0.2047e38))); |
| var vf1: vec2h = acosh(vec2h(round(vec4f(unconst_f32(0.06220), unconst_f32(0.3644e-30), unconst_f32(0.3542), unconst_f32(0.1972e22))).zy.rg.yy.rr)); |
| return out; |
| } |
| |
| struct ComputeInput3 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| override override0: f16; |
| |
| struct ComputeInput0 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct T1 { |
| f0: atomic<i32>, |
| } |
| |
| var<workgroup> vw2: atomic<u32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T2 { |
| @align(8) @size(32) f0: T1, |
| } |
| |
| /* used global variables: sam0 */ |
| fn fn1(a0: i32) -> vec2u { |
| var out: vec2u; |
| let ptr0: ptr<function, vec2u> = &out; |
| var vf2 = fn0(sam0); |
| let vf3: u32 = vf2[unconst_u32(467333467)]; |
| vf2 |= vec2u((*ptr0)[unconst_u32(58747457)]); |
| out |= vec2u(u32(a0)); |
| _ = fn0(sam0); |
| let vf4: vec2f = tanh(vec2f(unconst_f32(0.1090), unconst_f32(0.2551))); |
| out = out; |
| return out; |
| _ = sam0; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(4, 1, 1) |
| fn compute0(@builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, a3: ComputeInput0) { |
| atomicSub(&vw2, unconst_u32(354441726)); |
| loop { |
| let ptr1: ptr<workgroup, atomic<u32>> = &vw1[unconst_u32(531334364)]; |
| atomicAnd(&vw2, workgroup_id[unconst_u32(88185036)]); |
| let ptr2: ptr<workgroup, atomic<u32>> = &vw1[unconst_u32(1420491009)]; |
| let ptr3: ptr<workgroup, array<atomic<u32>, 1>> = &(*&vw1); |
| let ptr4: ptr<workgroup, atomic<u32>> = &(*ptr3)[unconst_u32(1299125040)]; |
| atomicSub(&vw0, unconst_u32(1401347106)); |
| break; |
| } |
| var vf5: u32 = atomicExchange(&vw2, unconst_u32(457132739)); |
| var vf6: vec3u = local_invocation_id; |
| atomicCompareExchangeWeak(&vw2, unconst_u32(1424555608), unconst_u32(1109369112)); |
| atomicStore(&vw1[unconst_u32(73234630)], unconst_u32(251358043)); |
| let ptr5: ptr<function, u32> = &vf5; |
| textureBarrier(); |
| let vf7: u32 = atomicLoad(&vw1[0]); |
| let ptr6: ptr<workgroup, atomic<u32>> = &vw1[unconst_u32(287296750)]; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute1(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a4: ComputeInput1) { |
| atomicExchange(&vw2, unconst_u32(39258931)); |
| atomicXor(&vw0, unconst_u32(71807738)); |
| var vf8: u32 = atomicLoad(&vw1[0]); |
| var vf9: u32 = atomicExchange(&(*&vw2), unconst_u32(2131339945)); |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute2(a0: ComputeInput2, a1: ComputeInput3, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(workgroup_id) workgroup_id: vec3u) { |
| let vf10: u32 = pack2x16snorm(vec2f(f32(atomicLoad(&(*&vw2))))); |
| let vf11: ComputeInput2 = a0; |
| let vf12: vec4f = ceil(vec4f(unconst_f32(0.00286e-39), unconst_f32(0.1833), unconst_f32(0.1988e-37), unconst_f32(-0.05506e-39))); |
| atomicExchange(&vw2, unconst_u32(390213240)); |
| atomicMin(&vw0, unconst_u32(986153183)); |
| atomicAdd(&vw1[0], unconst_u32(457839297)); |
| atomicAdd(&vw2, unconst_u32(163522733)); |
| atomicCompareExchangeWeak(&vw0, unconst_u32(973652385), unconst_u32(136232184)); |
| var vf13: u32 = a0.local_invocation_id[unconst_u32(1292573732)]; |
| }`, |
| }); |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false }, |
| }, |
| {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let texture19 = device0.createTexture({ |
| size: [1697, 1, 4], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture20 = device0.createTexture({ |
| size: [1697, 1, 6], |
| mipLevelCount: 4, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer1, 'uint32', 40, 43); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder6.insertDebugMarker('\u8207'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 245, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(10).fill(123), /* required buffer size: 10 */ |
| {offset: 10}, {width: 373, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer8 = device0.createBuffer({size: 17996, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let texture21 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder6 = commandEncoder6.beginComputePass(); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer1, 'uint16', 20, 33); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(24, 154); |
| let texture22 = device0.createTexture({ |
| size: [1, 178, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView11 = texture21.createView({}); |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false }, |
| }, |
| {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let buffer9 = device0.createBuffer({size: 24, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let textureView12 = texture19.createView({ |
| label: '\u0896\uc252\uf925\u0b63\u{1fbad}\u02e8\u9622\u1774\uc7dd\u36e0', |
| dimension: '2d', |
| arrayLayerCount: 1, |
| }); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame0}); |
| let commandEncoder8 = device1.createCommandEncoder({}); |
| let texture23 = device1.createTexture({ |
| size: {width: 2560}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let pipelineLayout2 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3, veryExplicitBindGroupLayout3]}); |
| let textureView13 = texture18.createView({baseMipLevel: 0}); |
| let computePassEncoder7 = commandEncoder8.beginComputePass(); |
| let texture24 = device1.createTexture({ |
| size: {width: 256}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture25 = device1.createTexture({ |
| size: [1280, 1, 1], |
| mipLevelCount: 4, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let textureView14 = texture12.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer1, 'uint16', 2, 106); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 2, |
| origin: {x: 76, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(128).fill(97), /* required buffer size: 128 */ |
| {offset: 128}, {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer10 = device0.createBuffer({size: 500, usage: GPUBufferUsage.INDEX}); |
| let texture26 = device0.createTexture({ |
| size: [8, 1424, 1], |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture27 = device0.createTexture({ |
| size: [8, 1424, 1], |
| sampleCount: 4, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder2.insertDebugMarker('\ud527'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu'); |
| let commandEncoder10 = device1.createCommandEncoder(); |
| let textureView15 = texture24.createView({format: 'r32float', baseMipLevel: 0}); |
| let texture28 = device1.createTexture({ |
| size: [408, 1, 1], |
| mipLevelCount: 3, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let pipelineLayout3 = device1.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout3], |
| }); |
| let buffer11 = device1.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let texture29 = device1.createTexture({ |
| size: [256, 256, 33], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder8 = commandEncoder10.beginComputePass(); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(389).fill(70), /* required buffer size: 389 */ |
| {offset: 389}, {width: 193, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture30 = device0.createTexture({ |
| size: [2, 356, 1], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer1, 'uint16', 18, 81); |
| } catch {} |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let texture31 = device0.createTexture({ |
| size: [2, 356, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture32 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture33 = device0.createTexture({ |
| size: [848, 1, 45], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView16 = texture21.createView({label: '\uf36b\u7116\u0ccd\uc6e1\u649b\u{1ffcd}\u{1f7e6}'}); |
| let computePassEncoder9 = commandEncoder11.beginComputePass(); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 424, height: 1, depthOrArrayLayers: 14} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 1, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 29, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let imageData0 = new ImageData(8, 4); |
| try { |
| adapter1.label = '\u004f\u{1fd27}\u7008\u672e'; |
| } catch {} |
| let textureView17 = texture25.createView({dimension: '2d', mipLevelCount: 1}); |
| await gc(); |
| let texture34 = device0.createTexture({ |
| size: {width: 2, height: 356, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer10, 'uint32', 500); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12, new Uint32Array(30860).map((_, i) => i * 6), 16104, 0); |
| } catch {} |
| let commandEncoder12 = device1.createCommandEncoder({}); |
| let textureView18 = texture25.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 64, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(74).fill(86), /* required buffer size: 74 */ |
| {offset: 74}, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer12 = device1.createBuffer({size: 224, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder13 = device1.createCommandEncoder(); |
| let renderBundleEncoder4 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], stencilReadOnly: false}); |
| let texture35 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 50}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer4, 'uint32', 0, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout7 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer13 = device1.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let textureView19 = texture24.createView({}); |
| let computePassEncoder10 = commandEncoder13.beginComputePass(); |
| try { |
| device1.queue.writeBuffer(buffer12, 8, new Float16Array(7249).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.7356)), 996, 4); |
| } catch {} |
| let promise0 = device1.queue.onSubmittedWorkDone(); |
| let texture36 = device1.createTexture({ |
| size: [19, 20, 539], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| device1.queue.writeBuffer(buffer12, 68, new Float64Array(52858).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/52856)), 17669, 16); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let textureView20 = texture34.createView({dimension: '2d-array'}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| let imageData1 = new ImageData(16, 104); |
| let pipelineLayout5 = device1.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout6]}); |
| let commandEncoder15 = device1.createCommandEncoder({}); |
| let textureView21 = texture18.createView({}); |
| try { |
| await promise0; |
| } catch {} |
| let commandEncoder16 = device1.createCommandEncoder({}); |
| let computePassEncoder11 = commandEncoder16.beginComputePass(); |
| try { |
| commandEncoder15.insertDebugMarker('\uaf00'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| globalThis.someLabel = buffer1.label; |
| } catch {} |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let textureView22 = texture14.createView({aspect: 'all'}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer1, 'uint32', 12, 44); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'smpte240m'} }); |
| let shaderModule1 = device1.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| @group(0) @binding(0) var st0: texture_storage_1d<r32float, read_write>; |
| |
| struct VertexInput4 { |
| @location(4) location_4: vec4f, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct ComputeInput4 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct VertexInput1 { |
| @location(6) @interpolate(flat, first) location_6: i32, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput5 { |
| @location(9) @interpolate(flat, first) location_9: u32, |
| } |
| |
| struct T2 { |
| @size(26) f0: atomic<u32>, |
| } |
| |
| struct VertexInput0 { |
| @location(1) location_1: f16, |
| @location(10) @interpolate(flat) location_10: f16, |
| } |
| |
| struct T5 { |
| f0: array<atomic<u32>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentOutput0 { |
| @location(4) @interpolate(flat, either) location_4: vec4u, |
| @location(0) location_0: vec4f, |
| } |
| |
| var<workgroup> vw3: bool; |
| |
| struct VertexInput3 { |
| @location(8) @interpolate(flat) location_8: vec2i, |
| @location(0) location_0: vec2h, |
| @location(14) location_14: vec4i, |
| } |
| |
| struct FragmentInput0 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| struct VertexInput6 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| @group(0) @binding(2) var<storage, read_write> buffer14: array<array<f16, 13>>; |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T4 { |
| f0: array<u32>, |
| } |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| struct T1 { |
| @size(26) f0: array<array<vec4i, 1>, 1>, |
| } |
| |
| struct VertexInput2 { |
| @location(5) location_5: vec2i, |
| @location(2) location_2: vec2h, |
| @location(11) @interpolate(flat) location_11: u32, |
| } |
| |
| struct T6 { |
| f0: array<u32>, |
| } |
| |
| @group(1) @binding(2) var<storage, read_write> buffer15: array<array<f16, 13>, 1>; |
| |
| @group(1) @binding(0) var st1: texture_storage_1d<r32float, read_write>; |
| |
| struct T7 { |
| @size(16) f0: atomic<i32>, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex0(@location(13) location_13: vec2u, @location(15) location_15: f16, a2: VertexInput0, a3: VertexInput1, a4: VertexInput2, a5: VertexInput3, @location(3) location_3: vec2h, a7: VertexInput4, a8: VertexInput5, @location(12) location_12: i32, @location(7) @interpolate(linear) location_7: vec4h, @builtin(vertex_index) vertex_index: u32, a12: VertexInput6) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = unpack4x8unorm(a12.instance_index); |
| out = vec4f(bitcast<f32>(location_12)); |
| out = asinh(vec3f(f32(location_7[unconst_u32(1794129708)]))).yzxy; |
| var vf14: i32 = insertBits(unconst_i32(29993911), unconst_i32(260681058), unconst_u32(1439666379), unconst_u32(182591578)); |
| out *= bitcast<vec4f>(a4.location_5.gggr.xyyx.yzxx.bgba); |
| var vf15: f16 = a2.location_10; |
| let vf16: vec4f = ldexp(vec4f(unconst_f32(0.08947e-19), unconst_f32(0.3287), unconst_f32(0.06209), unconst_f32(0.2756)), vec4i(bitcast<i32>((unconst_u32(436895946) << unconst_u32(4294967295))))); |
| let vf17: bool = (unconst_bool(true) && unconst_bool(true)); |
| out = bitcast<vec4f>(a4.location_5.yxyx); |
| return out; |
| } |
| |
| /* used global variables: buffer14, buffer15 */ |
| @fragment |
| fn fragment0(a0: FragmentInput0, @builtin(position) position: vec4f) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| let ptr7: ptr<storage, array<f16, 13>, read_write> = &(*&buffer15)[unconst_u32(491548134)]; |
| let ptr8: ptr<storage, f16, read_write> = &(*&buffer15)[unconst_u32(2467857238)][unconst_u32(2392806664)]; |
| for (var jj71=0u; jj71<15; jj71++) { buffer14[unconst_u32(397259175)][jj71] = (*&buffer15)[0][12]; } |
| out.location_4 = vec4u(u32((*&buffer14)[arrayLength(&(*&buffer14))][12])); |
| var vf18: FragmentInput0 = a0; |
| let ptr9: ptr<storage, array<f16, 13>, read_write> = &(*&buffer15)[unconst_u32(30927996)]; |
| out.location_0 = vec4f((vec3u(unconst_u32(111967757), unconst_u32(543195532), unconst_u32(477139718)) >= vec3u(u32((*&buffer15)[0][12]))).zzxz); |
| let ptr10: ptr<storage, array<f16, 13>, read_write> = &(*&buffer14)[unconst_i32(55148158)]; |
| out.location_4 ^= vec4u(u32(vf18.front_facing)); |
| let ptr11: ptr<storage, f16, read_write> = &(*ptr10)[12]; |
| let ptr12: ptr<storage, array<f16, 13>, read_write> = &buffer15[unconst_u32(1437911378)]; |
| let ptr13: ptr<storage, array<f16, 13>, read_write> = &buffer15[unconst_u32(371294992)]; |
| return out; |
| _ = buffer14; |
| _ = buffer15; |
| } |
| |
| /* used global variables: st0, st1 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute3(a0: ComputeInput4) { |
| vw3 = (*&vw3); |
| textureStore(st0, unconst_i32(1013261528), vec4f(vec4f(unconst_f32(0.4999e-8), unconst_f32(-0.4883), unconst_f32(0.05409e34), unconst_f32(0.07229)))); |
| let vf19: i32 = insertBits(unconst_i32(-712460652), unconst_i32(2014165987), pack2x16snorm(tanh(vec2f(unconst_f32(0.04443e3), unconst_f32(0.2238e35)))), unconst_u32(382651743)); |
| let vf20: f16 = length(vec4h(unconst_f16(18693.8), unconst_f16(-13586.9), unconst_f16(22529.8), unconst_f16(-2833.4))); |
| var vf21: u32 = textureDimensions(st0); |
| vf21 |= u32(length(bitcast<vec4h>(extractBits(vec2i(unconst_i32(527981195), unconst_i32(9848936)), unconst_u32(2737175954), unconst_u32(382597031))))); |
| _ = st1; |
| let vf22: vec2f = tanh(vec2f(unconst_f32(0.4738e-3), unconst_f32(0.4859e-13))); |
| textureStore(st1, i32(vf21), vec4f(vec4f(unconst_f32(0.2055e-8), unconst_f32(0.01059), unconst_f32(0.2562e-37), unconst_f32(0.3649)))); |
| _ = st1; |
| _ = st0; |
| }`, |
| }); |
| let commandEncoder18 = device1.createCommandEncoder({}); |
| let textureView23 = texture29.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| let pipeline0 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1}}); |
| let texture37 = device0.createTexture({ |
| size: [2, 356, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'}); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: [848, 1, 1], |
| dimension: '2d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture39 = device0.createTexture({ |
| size: [16, 16, 80], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer10, 'uint32', 68, 20); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(5, buffer2, 0, 29); |
| } catch {} |
| try { |
| renderBundleEncoder3.insertDebugMarker('\u06a2'); |
| } catch {} |
| try { |
| device1.label = '\u0056\u6929\ubb22'; |
| } catch {} |
| let autogeneratedBindGroupLayout0 = pipeline0.getBindGroupLayout(1); |
| let computePassEncoder12 = commandEncoder13.beginComputePass(); |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, undefined, 36_925_854); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let texture40 = device0.createTexture({ |
| size: [4, 712, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture41 = gpuCanvasContext1.getCurrentTexture(); |
| await gc(); |
| let texture42 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView24 = texture0.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let sampler4 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'not-equal', |
| }); |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer8, 2_460); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture33, |
| mipLevel: 0, |
| origin: {x: 122, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(28).fill(153), /* required buffer size: 28 */ |
| {offset: 28, rowsPerImage: 3}, {width: 167, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder21 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 0, new DataView(new Uint8Array(1985).map((_, i) => i).buffer), 406, 40); |
| } catch {} |
| let pipeline1 = await device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x4da36271}, |
| fragment: { |
| module: shaderModule1, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 40, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 16, shaderLocation: 7}, |
| {format: 'float16x4', offset: 0, shaderLocation: 1}, |
| {format: 'sint16x4', offset: 8, shaderLocation: 5}, |
| {format: 'float32x3', offset: 0, shaderLocation: 0}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint8x4', offset: 4, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 14}, |
| {format: 'uint8x2', offset: 4, shaderLocation: 11}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 4}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 6}, |
| {format: 'snorm8x2', offset: 8, shaderLocation: 3}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 2}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 13}, |
| {format: 'sint32', offset: 0, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 8}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip'}, |
| }); |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| var<workgroup> vw6: array<array<array<array<u32, 1>, 2>, 1>, 15>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct ComputeInput5 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| var<workgroup> vw4: atomic<u32>; |
| |
| @id(977) override override2: f32; |
| |
| var<workgroup> vw5: array<array<array<array<vec4u, 1>, 6>, 1>, 1>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| override override1: f16; |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct ComputeInput6 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 2) |
| fn compute4(@builtin(num_workgroups) num_workgroups: vec3u, a1: ComputeInput5, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a4: ComputeInput6) { |
| workgroupBarrier(); |
| let ptr14: ptr<workgroup, array<u32, 1>> = &vw6[unconst_u32(1127717973)][0][1]; |
| let ptr15: ptr<workgroup, u32> = &vw6[14][unconst_u32(753363658)][1][a4.local_invocation_id[2]]; |
| }`, |
| }); |
| let texture43 = device0.createTexture({size: [1697, 1, 1], format: 'r16sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| let texture44 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 17}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer9, 'uint32', 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, buffer8); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let imageData2 = new ImageData(60, 8); |
| let bindGroup0 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView15}]}); |
| let textureView25 = texture23.createView({arrayLayerCount: 1}); |
| let computePassEncoder13 = commandEncoder15.beginComputePass(); |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| let textureView26 = texture28.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder14 = commandEncoder12.beginComputePass(); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let renderBundleEncoder5 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float']}); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let promise1 = device1.queue.onSubmittedWorkDone(); |
| let commandEncoder22 = device1.createCommandEncoder({}); |
| let texture45 = device1.createTexture({ |
| size: [204, 1, 1], |
| mipLevelCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder6 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: false}); |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder22.clearBuffer(buffer12); |
| } catch {} |
| offscreenCanvas1.height = 471; |
| let videoFrame2 = new VideoFrame(videoFrame1, {timestamp: 0}); |
| let shaderModule3 = device1.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| struct T4 { |
| @align(8) @size(16) f0: array<u32, 1>, |
| } |
| |
| struct T3 { |
| f0: array<vec2<bool>>, |
| } |
| |
| var<workgroup> vw7: u32; |
| |
| var<workgroup> vw8: array<array<atomic<i32>, 1>, 22>; |
| |
| var<workgroup> vw9: atomic<i32>; |
| |
| struct ComputeInput8 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| struct T6 { |
| f0: atomic<u32>, |
| f1: array<u32>, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer16: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 2>, 2>>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T11 { |
| f0: array<atomic<u32>>, |
| } |
| |
| struct T7 { |
| f0: array<array<array<array<array<array<array<vec2f, 1>, 1>, 1>, 1>, 1>, 1>, 6>, |
| } |
| |
| @group(3) @binding(0) var st3: texture_storage_1d<r32float, read_write>; |
| |
| struct T10 { |
| f0: array<T7>, |
| } |
| |
| @group(1) @binding(0) var st2: texture_storage_1d<r32float, read_write>; |
| |
| struct T1 { |
| @size(784) f0: array<array<vec2u, 1>, 49>, |
| } |
| |
| struct T2 { |
| f0: array<vec4f>, |
| } |
| |
| struct ComputeInput10 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp0 = frexp(vec4h(6994.7, 2874.4, -9514.3, 6217.3)); |
| |
| struct ComputeInput9 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| struct ComputeInput7 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T9 { |
| @align(4) f0: array<array<vec2<bool>, 1>>, |
| } |
| |
| struct T8 { |
| f0: array<u32>, |
| } |
| |
| /* used global variables: buffer16, st2, st3 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute5(a0: ComputeInput7, a1: ComputeInput8, a2: ComputeInput9, @builtin(global_invocation_id) global_invocation_id: vec3u, a4: ComputeInput10) { |
| let ptr16: ptr<storage, f16, read_write> = &buffer16[arrayLength(&buffer16)][1][unconst_u32(982772891)][2][unconst_u32(47860297)][unconst_u32(311858670)][unconst_u32(2287701682)]; |
| textureStore(st3, unconst_i32(-28576040), vec4f(vec4f(unconst_f32(0.2313e26), unconst_f32(0.03022e-37), unconst_f32(0.2412e3), unconst_f32(0.03888e17)))); |
| let ptr17: ptr<workgroup, atomic<i32>> = &vw8[unconst_u32(2879107779)][unconst_u32(28486969)]; |
| while bool((*&buffer16)[arrayLength(&(*&buffer16))][1][unconst_u32(2490612288)][2][0][0][unconst_u32(1333015089)]) { |
| let ptr18: ptr<storage, f16, read_write> = &buffer16[unconst_u32(512006993)][1][1][unconst_u32(7079215)][unconst_u32(808955379)][0][unconst_u32(21913270)]; |
| textureStore(st3, unconst_i32(1093382151), vec4f(vec4f(unconst_f32(0.3372e-6), unconst_f32(-0.2394e26), unconst_f32(0.3666e22), unconst_f32(0.02849)))); |
| textureStore(st2, unconst_i32(9208624), vec4f(vec4f(unconst_f32(0.3077), unconst_f32(0.2603e2), unconst_f32(0.1160e-36), unconst_f32(0.00572e-28)))); |
| let ptr19: ptr<storage, f16, read_write> = &(*&buffer16)[unconst_u32(1175626556)][1][1][2][0][0][0]; |
| let ptr20: ptr<storage, f16, read_write> = &(*&buffer16)[arrayLength(&(*&buffer16))][u32((*&buffer16)[arrayLength(&(*&buffer16))][unconst_u32(775359330)][1][2][0][unconst_u32(319288547)][0])][unconst_u32(289249692)][2][unconst_u32(593347480)][unconst_u32(2595553333)][unconst_u32(246869041)]; |
| let ptr21: ptr<storage, f16, read_write> = &(*&buffer16)[arrayLength(&(*&buffer16))][u32((*&buffer16)[arrayLength(&(*&buffer16))][unconst_u32(429251698)][1][2][0][0][0])][1][2][unconst_u32(240134884)][0][0]; |
| _ = st3; |
| _ = st2; |
| _ = buffer16; |
| } |
| _ = buffer16; |
| _ = st3; |
| _ = st2; |
| }`, |
| }); |
| let commandEncoder23 = device1.createCommandEncoder({}); |
| let computePassEncoder15 = commandEncoder23.beginComputePass(); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup0, new Uint32Array(2911), 58, 0); |
| } catch {} |
| try { |
| device1.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(578).fill(171), /* required buffer size: 578 */ |
| {offset: 578}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler5 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.66, |
| maxAnisotropy: 3, |
| }); |
| let textureView27 = texture28.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(107).fill(233), /* required buffer size: 107 */ |
| {offset: 107, rowsPerImage: 27}, {width: 169, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpte240m', transfer: 'iec61966-2-1'} }); |
| let autogeneratedBindGroupLayout1 = pipeline1.getBindGroupLayout(1); |
| let buffer21 = device1.createBuffer({size: 233, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder24 = device1.createCommandEncoder(); |
| let texture46 = device1.createTexture({ |
| size: [156, 164, 1], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder22.copyTextureToTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 41, y: 37, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 55, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 48, y: 63, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder25 = device1.createCommandEncoder({}); |
| let texture47 = device1.createTexture({ |
| size: [2560, 1, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToBuffer(buffer13, 0, buffer12, 84, 24); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 52, new Float32Array(15875).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.627)), 1605, 16); |
| } catch {} |
| await gc(); |
| let textureView28 = texture47.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| let texture48 = device1.createTexture({ |
| size: {width: 320}, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView29 = texture23.createView({}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup0, []); |
| } catch {} |
| let bindGroup1 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView19}]}); |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup0, new Uint32Array(3446), 320, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.pushDebugGroup('\u5c04'); |
| } catch {} |
| try { |
| renderBundleEncoder5.popDebugGroup(); |
| } catch {} |
| try { |
| await promise1; |
| } catch {} |
| let texture49 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: false}); |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Float16Array(18253).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.5228)), 4453, 8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 7}, |
| aspect: 'all', |
| }, new Uint8Array(60_567).fill(170), /* required buffer size: 60_567 */ |
| {offset: 195, bytesPerRow: 78, rowsPerImage: 86}, {width: 5, height: 0, depthOrArrayLayers: 10}); |
| } catch {} |
| let renderBundleEncoder8 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture50 = device1.createTexture({ |
| size: [39, 41, 1], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder9 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| await gc(); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'smpteSt4281'} }); |
| let buffer22 = device1.createBuffer({size: 248, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let commandEncoder26 = device1.createCommandEncoder({}); |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} }); |
| let autogeneratedBindGroupLayout2 = pipeline0.getBindGroupLayout(1); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(1937), 21, 0); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| commandEncoder25.insertDebugMarker('\ue9ad'); |
| } catch {} |
| try { |
| renderBundleEncoder4.insertDebugMarker('\ua0fb'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture51 = device0.createTexture({ |
| size: [848, 1, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let veryExplicitBindGroupLayout9 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder27 = device1.createCommandEncoder({}); |
| let sampler6 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 9, |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| let pipeline2 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}}); |
| let imageData3 = new ImageData(44, 24); |
| let veryExplicitBindGroupLayout10 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 294, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| {binding: 354, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let buffer23 = device1.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder28 = device1.createCommandEncoder({}); |
| let texture52 = device1.createTexture({ |
| size: [51, 1, 141], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup0); |
| } catch {} |
| let promise2 = device1.queue.onSubmittedWorkDone(); |
| try { |
| await promise2; |
| } catch {} |
| let imageData4 = new ImageData(36, 24); |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let texture53 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 65}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView30 = texture1.createView({format: 'rgba16float', mipLevelCount: 1}); |
| await gc(); |
| let shaderModule4 = device1.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| override override6 = 0.2100; |
| |
| struct T6 { |
| f0: array<T2>, |
| } |
| |
| struct VertexInput10 { |
| @location(14) location_14: vec4i, |
| } |
| |
| @id(34792) override override8 = true; |
| |
| @group(0) @binding(98) var tex5: texture_2d<i32>; |
| |
| struct VertexInput9 { |
| @builtin(instance_index) instance_index: u32, |
| } |
| |
| struct VertexOutput0 { |
| @builtin(position) position: vec4f, |
| @location(1) location_1: vec4f, |
| @location(12) @interpolate(flat, sample) location_12: vec4u, |
| @location(9) location_9: vec2f, |
| @location(4) @interpolate(flat, centroid) location_4: i32, |
| @location(8) location_8: vec2i, |
| @location(15) location_15: vec2f, |
| @location(6) @interpolate(flat, either) location_6: vec2u, |
| } |
| |
| @id(34988) override override4: u32 = (1590390861 % 103) + 1; |
| |
| @id(42037) override override3: u32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw10: array<vec4f, 1>; |
| |
| struct FragmentInput1 { |
| @location(1) location_1: vec4f, |
| @builtin(sample_mask) sample_mask: u32, |
| @location(6) @interpolate(flat, either) location_6: vec2u, |
| @location(15) location_15: vec2f, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T3 { |
| f0: array<u32>, |
| } |
| |
| struct T2 { |
| f0: T0, |
| } |
| |
| @group(1) @binding(0) var<storage, read_write> buffer25: array<array<vec4h, 47>>; |
| |
| struct FragmentInput2 { |
| @location(9) location_9: vec2f, |
| @location(8) location_8: vec2i, |
| } |
| |
| struct T4 { |
| @align(16) @size(32) f0: T1, |
| @align(32) f1: array<atomic<u32>>, |
| } |
| |
| var<private> vp1 = array(modf(vec2h(25421.8, 1514.2))); |
| |
| struct ComputeInput12 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentOutput1 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(0) location_0: vec4i, |
| @location(7) location_7: f32, |
| @location(5) @interpolate(flat) location_5: vec2i, |
| } |
| |
| struct VertexInput8 { |
| @location(1) location_1: vec2i, |
| } |
| |
| struct VertexInput7 { |
| @location(2) location_2: i32, |
| @location(7) location_7: vec4f, |
| @location(15) location_15: i32, |
| @location(13) location_13: vec4f, |
| @location(12) @interpolate(flat) location_12: vec2u, |
| @location(0) location_0: f16, |
| @location(11) location_11: vec4i, |
| @location(4) @interpolate(perspective) location_4: vec4h, |
| @location(5) location_5: vec4u, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(9) @interpolate(flat, sample) location_9: u32, |
| @location(10) @interpolate(flat, center) location_10: vec4h, |
| @location(8) @interpolate(flat, either) location_8: u32, |
| } |
| |
| struct FragmentInput4 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| struct ComputeInput11 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct FragmentInput3 { |
| @location(12) @interpolate(flat, sample) location_12: vec4u, |
| } |
| |
| /* used global variables: tex8 */ |
| fn fn0(a0: ptr<function, array<f16, 77>>, a1: array<f32, 1>) { |
| let ptr22: ptr<function, f16> = &(*a0)[76]; |
| let ptr23: ptr<function, f16> = &(*a0)[76]; |
| (*a0)[unconst_u32(1154985285)] -= (*a0)[u32((*ptr22))]; |
| loop { |
| vp1[unconst_u32(293939199)].fract = vec2h(cosh(vec3f(unconst_f32(0.3702), unconst_f32(0.3256e-43), unconst_f32(0.01419e-14))).bg); |
| (*a0)[unconst_u32(64083294)] -= f16(a1[u32(a1[0])]); |
| continuing |
| { |
| vp1[unconst_u32(842795197)].whole = vec2h( !vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false)).zy); |
| for (var it0=u32((vec2i(unconst_i32(27925089), unconst_i32(277339348)) << bitcast<vec2u>(tan(vec4h(unconst_f16(212.1), unconst_f16(8417.3), unconst_f16(11847.6), unconst_f16(47176.4))))).r); it0<(bitcast<u32>(vp1[0].fract) & 0xfff); it0++) { |
| (*a0)[unconst_u32(838495432)] = f16(exp(vec3f(unconst_f32(0.06990), unconst_f32(0.1646e-17), unconst_f32(0.1015)))[1]); |
| var vf23: f16 = length(vec3h(unconst_f16(12384.0), unconst_f16(6411.5), unconst_f16(2667.8))); |
| vp1[unconst_u32(124880274)].fract = vec2h(textureLoad(tex8, vec2i(unconst_i32(-587902795), unconst_i32(196706159)), unconst_i32(135855976)).zz); |
| _ = tex8; |
| } |
| (*a0)[unconst_u32(411630112)] = f16(unconst_f16(-8299.7)); |
| _ = tex8; |
| } |
| return; |
| break; |
| _ = tex8; |
| } |
| (*a0)[bitcast<u32>(vp1[0].whole)] = vp1[unconst_u32(774395476)].whole[1]; |
| _ = tex8; |
| } |
| |
| /* zero global variables used */ |
| fn fn1() -> array<array<array<bool, 1>, 1>, 45> { |
| var out: array<array<array<bool, 1>, 1>, 45>; |
| let vf24: vec3f = asin(vec3f(unconst_f32(0.08710), unconst_f32(0.1179), unconst_f32(0.00451))); |
| let ptr24: ptr<function, array<bool, 1>> = &out[44][0]; |
| return out; |
| } |
| |
| @id(60087) override override7: bool; |
| |
| @group(3) @binding(2) var<storage, read_write> buffer29: array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 13>>; |
| |
| override override5: i32 = 29935959; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(3) @binding(98) var tex8: texture_2d<i32>; |
| |
| struct T5 { |
| @align(64) @size(768) f0: vec4<bool>, |
| @align(32) @size(704) f1: T1, |
| } |
| |
| struct T0 { |
| f0: array<atomic<u32>, 1>, |
| } |
| |
| struct T1 { |
| @size(16) f0: vec2i, |
| } |
| |
| /* used global variables: tex5 */ |
| @vertex |
| fn vertex1(a0: VertexInput7, @location(3) location_3: vec4f, a2: VertexInput8, @location(6) location_6: vec2h, a4: VertexInput9, a5: VertexInput10) -> VertexOutput0 { |
| var out: VertexOutput0; |
| out.location_4 = bitcast<vec3i>(mix(vec3f(unconst_f32(0.05784), unconst_f32(0.2665), unconst_f32(0.04280)), vec3f(unconst_f32(0.1041e-44), unconst_f32(0.07569e-45), unconst_f32(0.2518e8)), unconst_f32(0.05889)).zyx)[0]; |
| if bool(a4.instance_index) { |
| out.position -= bitcast<vec4f>(out.location_8.yyyx); |
| } |
| let vf25: vec2u = textureDimensions(tex5, unconst_i32(161686123)); |
| let vf26: f16 = a0.location_0; |
| var vf27 = fn1(); |
| let ptr25 = &vp1[0]; |
| out.location_1 += vec4f(out.location_15[unconst_u32(71717545)]); |
| out.position *= a0.location_13; |
| return out; |
| _ = tex5; |
| } |
| |
| /* used global variables: buffer29 */ |
| @fragment |
| fn fragment1(a0: FragmentInput1, @location(4) @interpolate(flat, either) location_4: i32, a2: FragmentInput2, a3: FragmentInput3, @builtin(position) position: vec4f, a5: FragmentInput4, @builtin(sample_index) sample_index: u32) -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let ptr26: ptr<storage, f16, read_write> = &buffer29[unconst_u32(60250063)][unconst_u32(704177181)][unconst_u32(538134838)][0][0][0]; |
| vp1[unconst_u32(98163296)].fract *= vec2h((*&buffer29)[unconst_u32(1439518397)][unconst_u32(515442352)][unconst_u32(539830304)][unconst_u32(254249298)][0][unconst_u32(1165191583)]); |
| var vf28 = fn1(); |
| return out; |
| _ = buffer29; |
| } |
| |
| /* used global variables: buffer25 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute6(a0: ComputeInput11, a1: ComputeInput12) { |
| let ptr27: ptr<storage, vec4h, read_write> = &buffer25[arrayLength(&buffer25)][unconst_u32(104414225)]; |
| let ptr28: ptr<storage, vec4h, read_write> = &buffer25[unconst_u32(500893890)][46]; |
| let vf29: f32 = override6; |
| _ = override6; |
| _ = buffer25; |
| }`, |
| }); |
| let buffer30 = device1.createBuffer({size: 25044, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let commandEncoder30 = device1.createCommandEncoder(); |
| let textureView31 = texture47.createView({dimension: '2d-array'}); |
| let textureView32 = texture36.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder8.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| let buffer31 = device1.createBuffer({size: 64, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let renderBundleEncoder10 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], stencilReadOnly: true}); |
| let buffer32 = device1.createBuffer({size: 100, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder31 = device1.createCommandEncoder({}); |
| try { |
| renderBundleEncoder6.insertDebugMarker('\u00ba'); |
| } catch {} |
| let buffer33 = device1.createBuffer({size: 115, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let texture54 = device1.createTexture({ |
| size: {width: 39}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture55 = device1.createTexture({ |
| size: [39, 41, 1], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer5, 16); }; |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer22, 0); |
| } catch {} |
| try { |
| await shaderModule4.getCompilationInfo(); |
| } catch {} |
| try { |
| device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let texture56 = device1.createTexture({ |
| size: {width: 102}, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder11 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], depthReadOnly: true, stencilReadOnly: true}); |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 44, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let textureView33 = texture14.createView({mipLevelCount: 1}); |
| let textureView34 = texture2.createView({}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer4, 'uint32', 32, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.insertDebugMarker('\u0220'); |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte432', transfer: 'unspecified'} }); |
| let texture57 = device1.createTexture({ |
| size: [39], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture58 = device1.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 26}, |
| mipLevelCount: 3, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(2, buffer33, 0); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer11, 4, buffer23, 4, 0); |
| } catch {} |
| let textureView35 = texture56.createView({format: 'rgba8uint'}); |
| let textureView36 = texture18.createView({dimension: '2d', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToBuffer(buffer13, 16, buffer30, 4608, 4); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm'], |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| globalThis.someLabel = pipeline0.label; |
| } catch {} |
| let commandEncoder33 = device1.createCommandEncoder(); |
| let texture59 = device1.createTexture({ |
| size: [256, 256, 34], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView37 = texture58.createView({mipLevelCount: 1, arrayLayerCount: 11}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup1); |
| } catch {} |
| let texture60 = device0.createTexture({ |
| size: [1697, 1, 61], |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture61 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView38 = texture53.createView({dimension: '2d'}); |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer10, 'uint16', 48, 30); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(1_489).fill(40), /* required buffer size: 1_489 */ |
| {offset: 32, bytesPerRow: 47, rowsPerImage: 29}, {width: 0, height: 3, depthOrArrayLayers: 2}); |
| } catch {} |
| let shaderModule5 = device1.createShaderModule({ |
| label: '\ud7a3\u6a77', |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw14: atomic<u32>; |
| |
| /* used global variables: buffer34 */ |
| fn fn0(a0: vec2i, a1: ptr<storage, f16, read_write>) { |
| for (var jj65=0u; jj65<3; jj65++) { buffer34[unconst_u32(3249047665)][u32((*&buffer34)[unconst_u32(292325360)][unconst_u32(86358417)][unconst_u32(566340961)][0])][2][jj65] = step(unconst_f16(1767.0), buffer34[unconst_u32(393974568)][unconst_u32(757978264)][2][unconst_u32(1914357286)]); } |
| return; |
| _ = buffer34; |
| } |
| |
| var<workgroup> vw13: atomic<i32>; |
| |
| struct T0 { |
| @size(26) f0: atomic<u32>, |
| } |
| |
| struct T1 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(3) @binding(2) var<storage, read_write> buffer38: array<array<array<f16, 1>, 13>>; |
| |
| var<workgroup> vw15: atomic<i32>; |
| |
| struct FragmentInput5 { |
| @location(9) location_9: vec2f, |
| } |
| |
| struct FragmentInput9 { |
| @location(1) location_1: vec4f, |
| } |
| |
| @group(0) @binding(0) var<storage, read_write> buffer34: array<array<array<array<f16, 1>, 3>, 4>>; |
| |
| @id(37089) override override10 = true; |
| |
| struct ComputeInput13 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| var<workgroup> vw18: vec2<bool>; |
| |
| var<workgroup> vw12: array<atomic<u32>, 1>; |
| |
| override override11: u32; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(3) @binding(0) var st8: texture_storage_1d<r32float, read_write>; |
| |
| override override9 = -450071326; |
| |
| @group(2) @binding(2) var<storage, read_write> buffer37: array<array<array<array<f16, 13>, 1>, 1>>; |
| |
| var<workgroup> vw11: atomic<u32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(1) @binding(0) var st6: texture_storage_1d<r32float, read_write>; |
| |
| struct FragmentInput8 { |
| @location(12) @interpolate(flat, sample) location_12: vec4u, |
| } |
| |
| struct FragmentInput6 { |
| @location(15) location_15: vec2f, |
| } |
| |
| @group(2) @binding(0) var st7: texture_storage_1d<r32float, read_write>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| var<workgroup> vw17: array<atomic<i32>, 1>; |
| |
| struct FragmentInput7 { |
| @location(4) @interpolate(flat, centroid) location_4: i32, |
| } |
| |
| @group(0) @binding(2) var<storage, read_write> buffer35: array<array<f16, 624>>; |
| |
| var<workgroup> vw16: vec4i; |
| |
| /* used global variables: buffer34, buffer35, buffer37, buffer38 */ |
| @fragment |
| fn fragment2(a0: FragmentInput5, a1: FragmentInput6, a2: FragmentInput7, @location(8) @interpolate(flat, sample) location_8: vec2i, a4: FragmentInput8, a5: FragmentInput9) -> @location(200) @interpolate(perspective) vec4i { |
| var out: vec4i; |
| let ptr29: ptr<storage, f16, read_write> = &(*&buffer37)[arrayLength(&(*&buffer37))][unconst_u32(275079149)][unconst_u32(926689189)][12]; |
| let ptr30: ptr<storage, f16, read_write> = &buffer35[arrayLength(&buffer35)][unconst_u32(356036144)]; |
| fn0(vec2i(i32(buffer37[arrayLength(&buffer37)][0][0][12])), &(*&buffer38)[arrayLength(&(*&buffer38))][unconst_u32(74630737)][0]); |
| fn0(vec2i(i32((*&buffer34)[u32(buffer37[unconst_u32(56905081)][unconst_u32(362970871)][unconst_u32(139359796)][12])][unconst_u32(348204072)][unconst_u32(1375009705)][unconst_u32(794707391)])), &buffer34[unconst_u32(372879513)][3][unconst_u32(409220151)][unconst_u32(616480589)]); |
| let ptr31: ptr<storage, array<f16, 1>, read_write> = &(*&buffer34)[arrayLength(&(*&buffer34))][3][2]; |
| return out; |
| _ = buffer38; |
| _ = buffer37; |
| _ = buffer35; |
| _ = buffer34; |
| } |
| |
| /* used global variables: buffer34, st6, st7, st8 */ |
| @compute @workgroup_size(2, 2, 1) |
| fn compute7(@builtin(local_invocation_index) local_invocation_index: u32, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, a3: ComputeInput13) { |
| let ptr32: ptr<workgroup, vec4i> = &vw16; |
| textureStore(st7, unconst_i32(30455327), vec4f(vec4f(unconst_f32(0.1326), unconst_f32(0.05903), unconst_f32(0.04720e37), unconst_f32(0.2257e33)))); |
| textureStore(st6, unconst_i32(138963263), vec4f(vec4f(unconst_f32(0.3284), unconst_f32(0.01332e-24), unconst_f32(0.00889), unconst_f32(0.03787)))); |
| textureStore(st8, unconst_i32(480957692), vec4f(vec4f(unconst_f32(0.00372), unconst_f32(0.3581), unconst_f32(0.1147), unconst_f32(0.01253e9)))); |
| textureStore(st7, unconst_i32(692363), vec4f(vec4f(unconst_f32(0.2747e0), unconst_f32(0.1639), unconst_f32(0.2199), unconst_f32(-0.3912)))); |
| textureStore(st8, unconst_i32(114619179), vec4f(vec4f(unconst_f32(0.1356e-42), unconst_f32(0.2379e13), unconst_f32(0.4067e-44), unconst_f32(0.06760e19)))); |
| fn0(vec2i(i32(buffer34[unconst_u32(742350960)][3][2][unconst_u32(530879824)])), &buffer34[arrayLength(&buffer34)][unconst_u32(249366969)][unconst_u32(230588921)][dot4U8Packed(pack4x8unorm(textureLoad(st7, unconst_i32(130681546))), unconst_u32(738906188))]); |
| _ = st7; |
| _ = st8; |
| _ = buffer34; |
| _ = st6; |
| }`, |
| }); |
| let autogeneratedBindGroupLayout3 = pipeline1.getBindGroupLayout(0); |
| let textureView39 = texture52.createView({aspect: 'all'}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup0); |
| } catch {} |
| let commandBuffer0 = commandEncoder13.finish(); |
| let texture62 = device1.createTexture({ |
| size: [19, 20, 9], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView40 = texture48.createView({}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup1, new Uint32Array(503), 21, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer32, 'uint32', 4, 12); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| await buffer13.mapAsync(GPUMapMode.WRITE, 152, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer23, 12, new DataView(new Uint8Array(13103).map((_, i) => i).buffer), 1547, 0); |
| } catch {} |
| let shaderModule6 = device1.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| var<workgroup> vw21: atomic<u32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T1 { |
| f0: array<vec2i>, |
| } |
| |
| var<workgroup> vw20: vec4<bool>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(2) var<storage, read_write> buffer39: array<array<array<array<array<f16, 13>, 1>, 1>, 1>>; |
| |
| @id(56479) override override13: f16 = 6601.8; |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw19: array<atomic<i32>, 1>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct FragmentOutput2 { |
| @location(0) location_0: vec4f, |
| @location(1) location_1: vec4u, |
| } |
| |
| @group(2) @binding(0) var<storage, read_write> buffer42: array<array<f16, 94>, 2>; |
| |
| struct VertexInput14 { |
| @location(3) @interpolate(flat) location_3: i32, |
| } |
| |
| struct T0 { |
| f0: atomic<i32>, |
| } |
| |
| @group(3) @binding(0) var st10: texture_storage_1d<r32float, read_write>; |
| |
| @group(2) @binding(1) var<storage, read_write> buffer43: u32; |
| |
| var<private> vp2: vec4h = vec4h(6044.9, 20609.3, 11746.5, 8823.7); |
| |
| @group(1) @binding(0) var<storage, read_write> buffer40: array<i32, 94>; |
| |
| override override15: f32; |
| |
| struct VertexInput15 { |
| @location(15) @interpolate(flat, first) location_15: vec4u, |
| } |
| |
| @id(5803) override override14: i32; |
| |
| struct VertexInput12 { |
| @location(0) @interpolate(flat) location_0: vec2u, |
| } |
| |
| struct T2 { |
| f0: array<vec2<bool>>, |
| } |
| |
| struct VertexInput11 { |
| @location(9) location_9: vec2i, |
| } |
| |
| struct VertexInput13 { |
| @location(10) location_10: vec4u, |
| } |
| |
| struct ComputeInput14 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| @id(51525) override override12: u32; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex2(a0: VertexInput11, @location(2) @interpolate(linear) location_2: vec4f, @location(14) location_14: f32, @location(13) location_13: vec4h, a4: VertexInput12, a5: VertexInput13, @location(1) location_1: vec4u, a7: VertexInput14, @location(11) location_11: f16, @location(5) @interpolate(flat) location_5: vec2i, a10: VertexInput15, @location(6) location_6: vec4u, @location(7) @interpolate(flat) location_7: i32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = vec4f((vec3u(unconst_u32(1084289261), unconst_u32(709217561), unconst_u32(2783665049)) > ~vec2u(unconst_u32(506035062), unconst_u32(75087546)).yxx).grbr); |
| vp2 *= bitcast<vec4h>((mat2x2f(unconst_f32(0.1138e-5), unconst_f32(0.3157), unconst_f32(0.02238), unconst_f32(0.2936)) + mat2x2f(unconst_f32(0.1871), unconst_f32(0.3274e32), unconst_f32(0.1069), unconst_f32(0.09090)))[unconst_i32(1)]); |
| return out; |
| } |
| |
| /* used global variables: buffer39, buffer43 */ |
| @fragment |
| fn fragment3() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| out.location_1 = vec4u(u32((*&buffer39)[arrayLength(&(*&buffer39))][0][0][0][12])); |
| buffer43 = u32((*&buffer39)[arrayLength(&(*&buffer39))][unconst_u32(401863238)][unconst_u32(696354199)][0][12]); |
| let ptr33: ptr<storage, array<array<array<array<f16, 13>, 1>, 1>, 1>, read_write> = &(*&buffer39)[unconst_i32(135719015)]; |
| let ptr34: ptr<storage, array<f16, 13>, read_write> = &(*&buffer39)[unconst_u32(340245634)][0][0][unconst_u32(259209717)]; |
| return out; |
| _ = buffer39; |
| _ = buffer43; |
| } |
| |
| /* used global variables: buffer40, buffer42, st10 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute8(a0: ComputeInput14, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u) { |
| buffer40[unconst_u32(744710018)] = i32(a0.local_invocation_index); |
| textureStore(st10, atomicLoad(&vw19[unconst_u32(2000019694)]), vec4f(vec4f(unconst_f32(0.01011), unconst_f32(0.2163), unconst_f32(0.4872e-27), unconst_f32(-0.1430e29)))); |
| let ptr35: ptr<workgroup, array<atomic<i32>, 1>> = &vw19; |
| let ptr36: ptr<storage, array<f16, 94>, read_write> = &(*&buffer42)[unconst_u32(1323056239)]; |
| let ptr37: ptr<storage, array<f16, 94>, read_write> = &(*&buffer42)[1]; |
| let ptr38: ptr<storage, f16, read_write> = &(*&buffer42)[unconst_u32(1470602299)][93]; |
| vp2 = vec4h(f16(atomicLoad(&vw19[unconst_u32(1241882383)]))); |
| _ = buffer40; |
| _ = buffer42; |
| _ = st10; |
| }`, |
| }); |
| let texture63 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 366}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture64 = device1.createTexture({size: {width: 256}, dimension: '1d', format: 'rg32float', usage: GPUTextureUsage.COPY_DST}); |
| let texture65 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder16 = commandEncoder30.beginComputePass(); |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer32, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(4, buffer33); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 0, y: 28 }, |
| flipY: false, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 50, y: 26, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet0 = device1.createQuerySet({type: 'occlusion', count: 386}); |
| let textureView41 = texture62.createView({}); |
| let texture66 = device1.createTexture({ |
| size: {width: 78}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| try { |
| computePassEncoder16.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 5, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 39}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 1, depthOrArrayLayers: 4}); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 12, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture58, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture67 = device0.createTexture({ |
| size: [1697, 1, 16], |
| mipLevelCount: 10, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture68 = device0.createTexture({ |
| size: [8, 1424, 1], |
| mipLevelCount: 9, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView42 = texture11.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 7}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture33, |
| mipLevel: 0, |
| origin: {x: 139, y: 0, z: 15}, |
| aspect: 'all', |
| }, new Uint8Array(248).fill(38), /* required buffer size: 248 */ |
| {offset: 248}, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture69 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView43 = texture9.createView({baseArrayLayer: 32, arrayLayerCount: 23}); |
| let computePassEncoder17 = commandEncoder20.beginComputePass(); |
| let veryExplicitBindGroupLayout12 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 68, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 236, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 379, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture70 = device1.createTexture({ |
| size: {width: 156}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView44 = texture58.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 2}); |
| let renderBundleEncoder12 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup0, []); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer21, 64); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 68, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 236, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 379, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer45 = device1.createBuffer({size: 7700, usage: GPUBufferUsage.INDIRECT}); |
| let commandEncoder34 = device1.createCommandEncoder({}); |
| let textureView45 = texture66.createView({aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1}); |
| let texture71 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 166}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder13 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup1, new Uint32Array(3945), 907, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer21); |
| } catch {} |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let texture72 = device0.createTexture({ |
| size: [8, 1424, 1], |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView46 = texture26.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| let buffer46 = device0.createBuffer({size: 5132, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture73 = device0.createTexture({ |
| size: [848, 1, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture74 = device0.createTexture({ |
| size: [1697, 1, 1], |
| mipLevelCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4}); |
| let textureView47 = texture56.createView({}); |
| let renderBundleEncoder15 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true}); |
| let sampler7 = device1.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 98.67}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup0, new Uint32Array(1075), 86, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let texture75 = device0.createTexture({ |
| size: [4, 712, 1], |
| sampleCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView48 = texture26.createView({dimension: '2d', mipLevelCount: 1}); |
| let imageBitmap0 = await createImageBitmap(imageData0); |
| let bindGroup2 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView15}]}); |
| let texture76 = device1.createTexture({ |
| size: [2560], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup0, new Uint32Array(227), 10, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(4, buffer22, 48, 16); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToBuffer(buffer13, 0, buffer31, 4, 0); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(294, 170); |
| let buffer47 = device0.createBuffer({size: 124, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let texture77 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct VertexInput20 { |
| @location(6) location_6: vec2f, |
| } |
| |
| struct ComputeInput15 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct VertexInput22 { |
| @location(15) location_15: vec2f, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T0 { |
| @size(16) f0: atomic<u32>, |
| @size(224) f1: atomic<u32>, |
| f2: array<array<array<vec4u, 1>, 1>>, |
| } |
| |
| struct T2 { |
| f0: array<u32, 1>, |
| } |
| |
| @group(0) @binding(0) var sam2: sampler; |
| |
| struct T1 { |
| f0: array<i32, 2>, |
| } |
| |
| struct ComputeInput16 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct VertexInput17 { |
| @location(5) @interpolate(flat, sample) location_5: vec2u, |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct VertexInput18 { |
| @location(13) location_13: vec4i, |
| @location(14) location_14: f16, |
| @location(9) location_9: vec4h, |
| @location(7) @interpolate(perspective, sample) location_7: vec2h, |
| @location(8) @interpolate(flat) location_8: u32, |
| @location(10) location_10: vec4u, |
| @location(2) location_2: vec4i, |
| } |
| |
| struct VertexInput16 { |
| @location(3) location_3: u32, |
| @location(4) @interpolate(flat) location_4: i32, |
| } |
| |
| /* zero global variables used */ |
| fn fn2(a0: sampler) -> vec2h { |
| var out: vec2h; |
| out = vec2h(floor(vec2f(unconst_f32(0.2342), unconst_f32(0.03633))).rr.yx); |
| out = vec2h(fma(vec4f(unconst_f32(-0.3382e35), unconst_f32(0.08308e37), unconst_f32(0.06859e-39), unconst_f32(0.06341)), vec4f(unconst_f32(0.04234e11), unconst_f32(0.3314e-33), unconst_f32(-0.05179e-12), unconst_f32(0.1087)), vec4f(f32(length(vec2h(unconst_f16(7652.3), unconst_f16(2432.8)))))).ra); |
| out -= pow(vec4h(unconst_f16(19016.6), unconst_f16(8154.2), unconst_f16(2972.8), unconst_f16(666.9)), vec4h(unconst_f16(11971.2), unconst_f16(4962.0), unconst_f16(6077.1), unconst_f16(140.8))).xw; |
| out = bitcast<vec2h>(pack2x16snorm(vec2f(unconst_f32(0.02920e-33), unconst_f32(0.2791e-9)))); |
| out -= vec2h(fma(vec4f(unconst_f32(0.08981e34), unconst_f32(0.4141e8), unconst_f32(0.2176e-36), unconst_f32(0.5855e-33)), vec4f(unconst_f32(1.000e-21), unconst_f32(-0.9321e-28), unconst_f32(0.00304), unconst_f32(0.04891)), floor(vec2f(unconst_f32(0.1700), unconst_f32(0.5450e-42))).rgrr).yy); |
| let vf36: vec3f = select(vec3f(unconst_f32(0.02886), unconst_f32(0.00966), unconst_f32(0.1372e-28)), vec3f(unconst_f32(0.1664e23), unconst_f32(0.01290), unconst_f32(0.3722)), vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false))); |
| out += vec2h(fract(unconst_f16(-14876.9))); |
| out = bitcast<vec2h>(pack2x16snorm(faceForward(round(vec4f(unconst_f32(0.1696e-24), unconst_f32(0.1646e20), unconst_f32(0.04622e30), unconst_f32(0.03288e-6))), vec4f(unconst_f32(0.06383e21), unconst_f32(0.1316e19), unconst_f32(0.01560), unconst_f32(0.4490e18)), vec4f(unconst_f32(0.1864e-33), unconst_f32(-0.1732e-15), unconst_f32(0.05229), unconst_f32(0.1989e35))).xy)); |
| let vf37: f32 = ldexp(unconst_f32(0.3074e10), unconst_i32(114014587)); |
| out += pow(vec4h(unconst_f16(-5222.4), unconst_f16(38076.6), unconst_f16(3408.1), unconst_f16(16411.9)), pow(vec2h(unconst_f16(2980.9), unconst_f16(7084.5)), vec2h(out[unconst_u32(87265602)])).gggr).xy; |
| out = round(vec3h(unconst_f16(6095.5), unconst_f16(2444.2), unconst_f16(23815.7))).zy; |
| out *= bitcast<vec2h>(vf37); |
| return out; |
| } |
| |
| struct VertexInput21 { |
| @location(0) location_0: vec2f, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexInput19 { |
| @location(1) @interpolate(linear, either) location_1: f32, |
| } |
| |
| /* zero global variables used */ |
| fn fn0() { |
| loop { |
| loop { |
| let vf30: vec2h = degrees(vec2h(unconst_f16(14595.9), unconst_f16(-2398.1))); |
| break; |
| } |
| let vf31: f16 = smoothstep(unconst_f16(34745.0), unconst_f16(1567.0), unconst_f16(2045.1)); |
| break; |
| } |
| var vf32: u32 = dot4U8Packed(unconst_u32(365189223), unconst_u32(651179358)); |
| } |
| |
| struct FragmentOutput3 { |
| @location(5) location_5: vec4f, |
| @location(2) location_2: vec2i, |
| @location(0) @interpolate(perspective) location_0: vec4f, |
| } |
| |
| /* used global variables: sam2 */ |
| fn fn1(a0: sampler) { |
| let vf33: f32 = exp2(unconst_f32(0.1702e-20)); |
| _ = sam2; |
| fn0(); |
| let vf34: vec2u = countOneBits(vec2u(unconst_u32(209812076), unconst_u32(213383380))); |
| _ = a0; |
| var vf35: vec3i = min(vec3i(unconst_i32(306962296), unconst_i32(73626135), unconst_i32(113203945)), vec3i(unconst_i32(392560721), unconst_i32(3215174), unconst_i32(563765876))); |
| vf35 = vec3i(vec3i(unconst_i32(629618309), unconst_i32(194255016), unconst_i32(239215163))); |
| _ = sam2; |
| } |
| |
| struct T4 { |
| @size(48) f0: array<T3, 1>, |
| @align(16) @size(16) f1: array<atomic<u32>, 1>, |
| f2: array<u32>, |
| } |
| |
| struct T3 { |
| @align(8) @size(8) f0: T2, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex3(a0: VertexInput16, @location(11) location_11: i32, a2: VertexInput17, a3: VertexInput18, @location(12) location_12: vec2h, a5: VertexInput19, a6: VertexInput20, a7: VertexInput21, a8: VertexInput22, @builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| fn0(); |
| out -= bitcast<vec4f>(select(vec3i(unconst_i32(24848795), unconst_i32(841373121), unconst_i32(498120809)), vec3i(i32(radians(unconst_f32(0.05729)))), vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false))).zxyz); |
| out += unpack4x8snorm(a2.vertex_index); |
| out += vec4f(a2.location_5.yyyx.raar.aagb.rgrr); |
| var vf38: f16 = a3.location_14; |
| out = vec4f(a3.location_2); |
| out += vec4f(f32(a3.location_7[unconst_u32(2870814000)])); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment4(@invariant @builtin(position) position: vec4f) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| fn0(); |
| return out; |
| } |
| |
| /* used global variables: sam2 */ |
| @compute @workgroup_size(1, 1, 2) |
| fn compute9(@builtin(local_invocation_id) local_invocation_id: vec3u, a1: ComputeInput15, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32, a4: ComputeInput16) { |
| fn2(sam2); |
| fn0(); |
| _ = sam2; |
| }`, |
| }); |
| let texture78 = device0.createTexture({ |
| size: [424, 1, 43], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture79 = device0.createTexture({ |
| size: {width: 4, height: 712, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView49 = texture22.createView({}); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame2}); |
| await gc(); |
| let img0 = await imageWithData(167, 4, '#10101010', '#20202020'); |
| let buffer48 = device0.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let texture80 = device0.createTexture({ |
| size: [8, 1424, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4}); |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer8, 0, 1_103); |
| } catch {} |
| let imageData5 = new ImageData(20, 16); |
| let buffer49 = device0.createBuffer({ |
| size: 253, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let texture81 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture82 = device0.createTexture({ |
| size: [16, 16, 27], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder18 = commandEncoder17.beginComputePass(); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let texture83 = device1.createTexture({ |
| size: {width: 102, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer31, 0, 2); |
| } catch {} |
| try { |
| commandEncoder22.resolveQuerySet(querySet0, 0, 6, buffer5, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let texture84 = device0.createTexture({ |
| size: {width: 8, height: 1424, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture85 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView50 = texture19.createView({dimension: '2d'}); |
| let texture86 = device0.createTexture({ |
| size: {width: 16, height: 16, depthOrArrayLayers: 27}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 70, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(13).fill(190), /* required buffer size: 13 */ |
| {offset: 13}, {width: 142, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView51 = texture86.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 7, arrayLayerCount: 6}); |
| let texture87 = device0.createTexture({size: [8], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC}); |
| let texture88 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer30, 20_232, new Float32Array(3932).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.638)), 503, 124); |
| } catch {} |
| let texture89 = device1.createTexture({size: [2560], dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let computePassEncoder19 = commandEncoder25.beginComputePass(); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer45, 488); }; |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(2, bindGroup1, new Uint32Array(119), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder37 = device0.createCommandEncoder(); |
| let texture90 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 84}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas2.getContext('webgpu'); |
| document.body.append(img0); |
| let commandEncoder38 = device1.createCommandEncoder(); |
| let texture91 = device1.createTexture({size: [256, 256, 12], format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let externalTexture7 = device1.importExternalTexture({source: videoFrame3}); |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup2, new Uint32Array(499), 152, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer33, 0, 51); |
| } catch {} |
| try { |
| commandEncoder38.clearBuffer(buffer23); |
| } catch {} |
| try { |
| commandEncoder24.pushDebugGroup('\u{1fe2b}'); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 12, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 2, y: 101 }, |
| flipY: false, |
| }, { |
| texture: texture58, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder39 = device1.createCommandEncoder({}); |
| let textureView52 = texture36.createView({arrayLayerCount: 1}); |
| let renderBundleEncoder18 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true}); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer5, 4); }; |
| } catch {} |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Float32Array(1464).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.320)), 174, 8); |
| } catch {} |
| let commandEncoder40 = device1.createCommandEncoder(); |
| let texture92 = device1.createTexture({ |
| size: [640, 1, 1], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer13, 4, buffer31, 16, 12); |
| } catch {} |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct VertexInput23 { |
| @location(5) @interpolate(flat, either) location_5: vec4i, |
| } |
| |
| @group(0) @binding(0) var sam3: sampler; |
| |
| struct ComputeInput17 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| struct T1 { |
| @size(448) f0: array<vec4f, 11>, |
| f1: array<atomic<u32>>, |
| } |
| |
| override override16: i32; |
| |
| override override17: bool; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| @size(34) f0: array<vec4f, 1>, |
| } |
| |
| struct VertexOutput1 { |
| @location(12) location_12: u32, |
| @invariant @builtin(position) position: vec4f, |
| @location(6) @interpolate(flat, first) location_6: u32, |
| } |
| |
| struct VertexInput25 { |
| @location(3) location_3: vec2f, |
| @location(9) location_9: i32, |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| var<private> vp3: vec4u = vec4u(24226650, 394249774, 490580452, 1097881783); |
| |
| struct T4 { |
| f0: array<u32>, |
| } |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct T2 { |
| @align(8) f0: array<atomic<i32>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentOutput4 { |
| @location(3) location_3: u32, |
| @location(7) location_7: vec4i, |
| @location(0) @interpolate(flat) location_0: vec4f, |
| } |
| |
| struct VertexInput24 { |
| @location(12) @interpolate(perspective) location_12: vec4h, |
| @location(0) location_0: u32, |
| @location(8) location_8: vec2u, |
| @location(13) location_13: vec4h, |
| @location(6) @interpolate(flat) location_6: i32, |
| @location(15) @interpolate(perspective) location_15: vec2h, |
| @location(14) location_14: vec2f, |
| @location(4) @interpolate(flat) location_4: vec4i, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T3 { |
| f0: array<atomic<u32>>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex4(a0: VertexInput23, a1: VertexInput24, a2: VertexInput25, @location(2) @interpolate(perspective, center) location_2: vec4f, @location(10) location_10: f16, @location(1) location_1: vec4h, @location(7) @interpolate(flat) location_7: vec2u) -> VertexOutput1 { |
| var out: VertexOutput1; |
| out.position *= vec4f(a1.location_8.grrg.xzzx.yyyz); |
| var vf39: mat3x2h = (mat3x2h(unconst_f16(3564.0), unconst_f16(9828.8), unconst_f16(15599.4), unconst_f16(16158.3), unconst_f16(368.4), unconst_f16(-13936.4)) + mat3x2h(unconst_f16(2796.1), unconst_f16(12810.1), unconst_f16(3799.6), unconst_f16(-25463.8), unconst_f16(12360.9), unconst_f16(17572.6))); |
| let vf40: f32 = location_2[unconst_u32(856524387)]; |
| vp3 >>= vec4u(out.location_6); |
| var vf41: vec4h = a1.location_12; |
| var vf42: i32 = a1.location_4[unconst_u32(167839260)]; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment5() -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| let vf43: vec2f = unpack2x16unorm(unconst_u32(1803416637)); |
| out.location_3 >>= pack2x16unorm(vec2f(unconst_f32(0.2546e22), unconst_f32(0.03249e-23))); |
| let ptr39: ptr<function, u32> = &out.location_3; |
| out.location_7 *= vec4i(normalize(vec3h(unconst_f16(11844.5), unconst_f16(10635.1), unconst_f16(1047.2))).zyxy); |
| out.location_0 = bitcast<vec4f>(out.location_7.baab); |
| if bool(normalize(vec3h(unconst_f16(1660.8), unconst_f16(4571.0), unconst_f16(8242.3))).b) { |
| var vf44: vec4h = exp(vec4h(unconst_f16(2207.0), unconst_f16(15512.5), unconst_f16(12567.7), unconst_f16(11969.1))); |
| out.location_3 &= vp3[u32(override17)]; |
| out.location_7 = unpack4xI8(countTrailingZeros(unconst_u32(319588710))); |
| while bool(out.location_3) { |
| out.location_0 += unpack4x8unorm(unconst_u32(361348781)); |
| { |
| let vf45: mat2x3h = (mat2x3h(unconst_f16(5833.8), unconst_f16(5813.0), unconst_f16(8479.8), unconst_f16(5544.5), unconst_f16(8017.2), unconst_f16(25974.1)) + mat2x3h(unconst_f16(6453.4), unconst_f16(30220.4), unconst_f16(427.9), unconst_f16(16639.1), unconst_f16(3705.3), unconst_f16(6398.5))); |
| break; |
| } |
| break; |
| } |
| { |
| let vf46: u32 = pack2x16unorm(vec2f(unconst_f32(0.1255), unconst_f32(0.3922))); |
| out.location_3 -= u32(override16); |
| out.location_3 |= vec2u(max(vec2f(unconst_f32(0.1217e-36), unconst_f32(0.4306)), vec2f(bitcast<f32>(out.location_7[unconst_u32(775017818)])))).g; |
| var vf47: vec3h = sin(vec3h(unconst_f16(2141.9), unconst_f16(8205.7), unconst_f16(7436.9))); |
| _ = override16; |
| } |
| var vf48: u32 = pack4xI8(vec4i(unconst_i32(214612935), unconst_i32(191258900), unconst_i32(1875137452), unconst_i32(71090150))); |
| _ = override16; |
| _ = override17; |
| } |
| let ptr40: ptr<function, FragmentOutput4> = &out; |
| return out; |
| _ = override17; |
| _ = override16; |
| } |
| |
| /* used global variables: sam3 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute10(a0: ComputeInput17, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_id) local_invocation_id: vec3u) { |
| var vf49: u32 = a0.local_invocation_index; |
| _ = sam3; |
| let vf50: vec2<bool> = (vec2h(unconst_f16(34547.3), unconst_f16(2041.6)) < vec2h(workgroup_id.yz.rr)); |
| vf49 <<= vp3[u32(all(vf50))]; |
| vp3 = vec4u(vp3[unconst_u32(587149260)]); |
| vp3 -= unpack4xU8(u32(vf50[unconst_u32(167906817)])); |
| for (var it1=u32(all((vec2h(unconst_f16(25048.8), unconst_f16(6891.0)) < vec2h(unconst_f16(13963.6), unconst_f16(5082.8))))); it1<(u32(override17) & 0xfff); it1++) { |
| vp3 = vec4u((unconst_f16(3893.5) + vec4h(unconst_f16(30000.6), unconst_f16(9314.1), unconst_f16(2854.5), unconst_f16(3599.8))).yyxx.wxww); |
| } |
| vf49 = bitcast<u32>(override16); |
| _ = override17; |
| _ = override16; |
| _ = sam3; |
| }`, |
| }); |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView53 = texture85.createView({label: '\u24c5\udde5\u0c30', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer47, 'uint32', 12, 14); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(2, buffer8, 0); |
| } catch {} |
| let textureView54 = texture91.createView({dimension: 'cube'}); |
| let computePassEncoder20 = commandEncoder39.beginComputePass(); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup2, new Uint32Array(4072), 1_655, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer32, 'uint16', 6, 4); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder21.copyTextureToTexture({ |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 0, y: 17, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 1, y: 9, z: 118}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let img1 = await imageWithData(108, 47, '#10101010', '#20202020'); |
| let commandEncoder42 = device0.createCommandEncoder(); |
| let texture93 = device0.createTexture({ |
| size: [424], |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture94 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView55 = texture33.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer8, 5_392, 4_262); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 24, new DataView(new ArrayBuffer(17190)), 129, 4); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let texture95 = gpuCanvasContext0.getCurrentTexture(); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let texture96 = device0.createTexture({size: [1697, 1, 75], dimension: '3d', format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderBundleEncoder14.setVertexBuffer(3, buffer8, 0, 8_878); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'}); |
| } catch {} |
| let gpuCanvasContext3 = canvas0.getContext('webgpu'); |
| document.body.append(img0); |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [{binding: 1, resource: {buffer: buffer49, size: 56}}], |
| }); |
| let commandEncoder44 = device0.createCommandEncoder({label: '\u674f\uc796\ub911\u7f3a\u{1fed5}\u5246\uefae\ue5e1\ufea1'}); |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'bt709'} }); |
| let buffer50 = device1.createBuffer({ |
| size: 81, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder45 = device1.createCommandEncoder({}); |
| let texture97 = device1.createTexture({ |
| size: {width: 78}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder19 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], depthReadOnly: true}); |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup2, new Uint32Array(1375), 44, 0); |
| } catch {} |
| try { |
| device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); }); |
| } catch {} |
| let bindGroup4 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView15}]}); |
| let commandEncoder46 = device1.createCommandEncoder({}); |
| let renderBundleEncoder20 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer5, 4); }; |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer32, 'uint16', 12, 1); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline3 = await device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, targets: [{format: 'rgba16float', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 392, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint8x2', offset: 26, shaderLocation: 11}, |
| {format: 'float16x2', offset: 84, shaderLocation: 7}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 5}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 15}, |
| {format: 'unorm16x4', offset: 20, shaderLocation: 0}, |
| {format: 'unorm16x2', offset: 60, shaderLocation: 6}, |
| {format: 'unorm8x2', offset: 2, shaderLocation: 13}, |
| {format: 'sint32', offset: 124, shaderLocation: 2}, |
| {format: 'float16x4', offset: 48, shaderLocation: 3}, |
| {format: 'snorm8x2', offset: 14, shaderLocation: 10}, |
| {format: 'uint8x4', offset: 44, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 8}, |
| {format: 'sint8x4', offset: 60, shaderLocation: 1}, |
| {format: 'sint8x4', offset: 52, shaderLocation: 14}, |
| {format: 'uint32', offset: 36, shaderLocation: 12}, |
| ], |
| }, |
| { |
| arrayStride: 184, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x2', offset: 16, shaderLocation: 4}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw'}, |
| }); |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView51}, |
| {binding: 30, resource: {buffer: buffer49, size: 16}}, |
| {binding: 103, resource: externalTexture3}, |
| {binding: 9, resource: textureView5}, |
| ], |
| }); |
| let commandEncoder47 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup5, new Uint32Array(1396), 18, 0); |
| } catch {} |
| try { |
| commandEncoder43.copyTextureToTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 311, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline4 = device0.createRenderPipeline({ |
| label: '\u{1fe6d}\u0843\uf67a\u8d47\u6c64\u0dac', |
| layout: pipelineLayout4, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule8, |
| constants: {override17: 1, override16: 1}, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'dst-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule8, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 36, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint8x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint32x2', offset: 4, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 10, shaderLocation: 5}, |
| {format: 'snorm16x2', offset: 8, shaderLocation: 14}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 4}, |
| {format: 'uint8x2', offset: 22, shaderLocation: 0}, |
| {format: 'unorm8x4', offset: 12, shaderLocation: 13}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 7}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 15}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 44, |
| stepMode: 'instance', |
| attributes: [{format: 'float16x2', offset: 0, shaderLocation: 2}, {format: 'sint8x2', offset: 0, shaderLocation: 6}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'front', |
| unclippedDepth: false, |
| }, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer45, 776); }; |
| } catch {} |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer32, 'uint32', 16, 8); |
| } catch {} |
| try { |
| commandEncoder24.copyTextureToTexture({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 11}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture0.label; |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [{binding: 1, resource: {buffer: buffer49, offset: 0, size: 72}}], |
| }); |
| let texture98 = device0.createTexture({ |
| size: [2], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer3, 16, new DataView(new Uint8Array(8910).map((_, i) => i).buffer), 5572, 4); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(34).fill(165), /* required buffer size: 34 */ |
| {offset: 34}, {width: 136, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline5 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, constants: {override17: 1, override16: 1}}}); |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 30, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 13, hasDynamicOffset: false }, |
| }, |
| {binding: 103, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let textureView56 = texture40.createView({}); |
| try { |
| computePassEncoder6.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer2, 0, 13); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let commandEncoder49 = device1.createCommandEncoder({}); |
| let textureView57 = texture46.createView({dimension: '2d-array', format: 'rgba16float', baseMipLevel: 0}); |
| let computePassEncoder21 = commandEncoder18.beginComputePass(); |
| let renderBundleEncoder21 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| let texture99 = device1.createTexture({ |
| size: [102, 1, 1], |
| sampleCount: 1, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(1, buffer21, 16); |
| } catch {} |
| try { |
| device1.pushErrorScope('validation'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let texture100 = device1.createTexture({ |
| size: [408], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture101 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView58 = texture59.createView({format: 'r32sint'}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer45, 260); }; |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(1605), 70, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(1, buffer31, 4, 15); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer49, size: 76}}, |
| {binding: 103, resource: externalTexture0}, |
| {binding: 13, resource: textureView51}, |
| {binding: 9, resource: textureView5}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'timestamp', count: 269}); |
| let texture102 = device0.createTexture({ |
| size: [424, 1, 36], |
| mipLevelCount: 6, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView59 = texture27.createView({}); |
| let renderPassEncoder0 = commandEncoder41.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: 238.2, g: 494.3, b: 767.4, a: -594.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder5.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder50.copyTextureToBuffer({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 26, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3128 */ |
| offset: 3128, |
| bytesPerRow: 4608, |
| buffer: buffer46, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(18, 16); |
| let veryExplicitBindGroupLayout15 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| {binding: 31, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 62, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 120, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 138, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let bindGroup8 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView15}]}); |
| let buffer51 = device1.createBuffer({size: 440, usage: GPUBufferUsage.INDIRECT}); |
| let texture103 = device1.createTexture({ |
| size: [78], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder22 = commandEncoder26.beginComputePass(); |
| let renderPassEncoder1 = commandEncoder49.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView57, |
| clearValue: { r: 833.2, g: -406.4, b: -836.8, a: 238.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 15886176, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup4, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup1, new Uint32Array(2794), 124, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| commandEncoder21.copyTextureToTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 19}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture64, |
| mipLevel: 0, |
| origin: {x: 87, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup7, new Uint32Array(3253), 826, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| texture33.label = '\u7aea\ua79f'; |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer2); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 80} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 7, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture104 = device1.createTexture({ |
| size: [1280], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView60 = texture56.createView({}); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(4, buffer33, 4, 58); |
| } catch {} |
| try { |
| adapter0.label = '\uf66a\u02a1\u9fee\u27f5\u02ba\u{1fd1f}\u34a2\ua0cf\ub9ff'; |
| } catch {} |
| let commandEncoder51 = device1.createCommandEncoder({}); |
| let texture105 = device1.createTexture({ |
| size: {width: 51}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture106 = device1.createTexture({ |
| size: [51, 1, 17], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float'], |
| }); |
| try { |
| commandEncoder31.copyTextureToBuffer({ |
| texture: texture104, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 796 widthInBlocks: 199 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2492 */ |
| offset: 2492, |
| bytesPerRow: 4608, |
| buffer: buffer30, |
| }, {width: 199, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let texture107 = device0.createTexture({ |
| size: {width: 8, height: 1424, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'eac-r11unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer47, 'uint16', 14, 13); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let textureView61 = texture16.createView({mipLevelCount: 1}); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup3, new Uint32Array(2532), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer4, 'uint32', 4, 19); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(5, buffer2, 0, 23); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 520, new Uint32Array(14713).map((_, i) => i * 5), 556, 76); |
| } catch {} |
| let buffer52 = device1.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC}); |
| let commandEncoder54 = device1.createCommandEncoder({}); |
| let texture108 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder23 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer5, 20); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer32, 'uint16', 2, 5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer32, 12, 14); |
| } catch {} |
| try { |
| buffer52.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u04c1'); |
| } catch {} |
| try { |
| device1.queue.submit([commandBuffer0]); |
| } catch {} |
| let pipeline6 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment3', |
| constants: {}, |
| targets: [{format: 'rgba16float', writeMask: 0}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 36, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 0, shaderLocation: 6}, |
| {format: 'float16x2', offset: 0, shaderLocation: 1}, |
| {format: 'uint16x2', offset: 4, shaderLocation: 13}, |
| {format: 'sint8x2', offset: 8, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'float16x2', offset: 4, shaderLocation: 10}, |
| {format: 'float32x3', offset: 0, shaderLocation: 3}, |
| {format: 'float32x4', offset: 0, shaderLocation: 15}, |
| {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 2}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 7}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 5}, |
| {format: 'float32x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 11}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 4, shaderLocation: 0}, |
| ], |
| }, |
| {arrayStride: 0, attributes: [{format: 'sint32x4', offset: 532, shaderLocation: 14}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let texture109 = device1.createTexture({ |
| size: {width: 408}, |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture110 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 74}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(4, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer45, 1_788); }; |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 3, y: 211 }, |
| flipY: true, |
| }, { |
| texture: texture58, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 103, resource: externalTexture5}, |
| {binding: 30, resource: {buffer: buffer49, offset: 0, size: 56}}, |
| {binding: 13, resource: textureView51}, |
| {binding: 9, resource: textureView5}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let renderPassEncoder2 = commandEncoder9.beginRenderPass({ |
| colorAttachments: [{view: textureView59, loadOp: 'load', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 265}, |
| }); |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| commandEncoder14.clearBuffer(buffer3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 848, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 2, |
| origin: {x: 417, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}}); |
| let canvas1 = document.createElement('canvas'); |
| let buffer53 = device1.createBuffer({size: 428, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandBuffer1 = commandEncoder23.finish(); |
| let textureView62 = texture103.createView({}); |
| let textureView63 = texture45.createView({arrayLayerCount: 1}); |
| try { |
| commandEncoder24.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let recycledExplicitBindGroupLayout0 = pipeline7.getBindGroupLayout(0); |
| let textureView64 = texture19.createView({dimension: '2d'}); |
| try { |
| computePassEncoder18.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await shaderModule7.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder42.insertDebugMarker('\u8948'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12, new Float16Array(1762).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.3431)), 241, 4); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 346, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(97).fill(14), /* required buffer size: 97 */ |
| {offset: 97}, {width: 1109, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer54 = device0.createBuffer({size: 92, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder55 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder3.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToBuffer(buffer0, 4, buffer3, 12, 8); |
| } catch {} |
| try { |
| commandEncoder43.resolveQuerySet(querySet1, 223, 0, buffer1, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 180, new Uint16Array(30193).map((_, i) => i + 4), 5201, 204); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let texture111 = device0.createTexture({ |
| size: {width: 2}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| commandEncoder35.copyTextureToBuffer({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 2}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 224 */ |
| offset: 224, |
| bytesPerRow: 10240, |
| buffer: buffer46, |
| }, {width: 0, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder53.pushDebugGroup('\ua59e'); |
| } catch {} |
| try { |
| commandEncoder53.popDebugGroup(); |
| } catch {} |
| let shaderModule9 = device1.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| var<workgroup> vw22: i32; |
| |
| struct VertexInput29 { |
| @location(14) @interpolate(flat, sample) location_14: vec2i, |
| } |
| |
| var<workgroup> vw23: atomic<i32>; |
| |
| @group(3) @binding(98) var tex17: texture_2d<i32>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct VertexInput31 { |
| @location(0) @interpolate(flat, first) location_0: u32, |
| } |
| |
| override override24: f16 = 6808.3; |
| |
| @id(27848) override override22 = true; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @id(64436) override override21 = 0.00812e-8; |
| |
| @id(5349) override override23: u32; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(2) var<storage, read_write> buffer55: array<array<array<array<array<array<array<f16, 13>, 1>, 1>, 1>, 1>, 1>>; |
| |
| struct T1 { |
| f0: array<T0>, |
| } |
| |
| @id(7569) override override18 = 0.2195; |
| |
| struct FragmentOutput5 { |
| @location(0) location_0: vec4u, |
| @location(1) @interpolate(perspective) location_1: vec4f, |
| @builtin(sample_mask) sample_mask: u32, |
| @location(3) @interpolate(flat) location_3: vec2i, |
| @location(4) @interpolate(flat) location_4: u32, |
| } |
| |
| @id(38701) override override25: i32; |
| |
| struct VertexInput30 { |
| @location(2) @interpolate(flat) location_2: i32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(2) @binding(1) var<storage, read_write> buffer59: T1; |
| |
| struct VertexInput27 { |
| @location(11) location_11: vec2i, |
| @location(15) @interpolate(flat, center) location_15: vec4i, |
| @location(10) location_10: vec4f, |
| } |
| |
| override override19: i32; |
| |
| struct VertexInput26 { |
| @location(4) @interpolate(flat) location_4: vec2u, |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(277) override override20: f16; |
| |
| struct VertexInput28 { |
| @location(8) @interpolate(flat) location_8: vec2f, |
| } |
| |
| struct FragmentInput10 { |
| @builtin(sample_index) sample_index: u32, |
| } |
| |
| struct FragmentInput11 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| struct T0 { |
| f0: array<array<atomic<i32>, 1>, 1>, |
| } |
| |
| /* used global variables: tex17 */ |
| @vertex |
| fn vertex5(@location(1) @interpolate(flat) location_1: vec2i, @location(13) location_13: vec4f, @location(3) @interpolate(linear) location_3: vec2h, @location(6) @interpolate(flat) location_6: vec2u, @location(5) @interpolate(flat, first) location_5: vec4i, @location(12) location_12: f32, a6: VertexInput26, a7: VertexInput27, a8: VertexInput28, @location(7) location_7: vec2f, a10: VertexInput29, a11: VertexInput30, @location(9) location_9: vec2u, a13: VertexInput31, @builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| var vf51: i32 = a11.location_2; |
| out = vec4f(f32(a6.vertex_index)); |
| out = vec4f(bitcast<f32>(override19)); |
| let vf52: vec3f = cross(vec3f(unconst_f32(0.4783e-27), unconst_f32(0.02274e-45), unconst_f32(0.05888)), vec3f(unconst_f32(0.07328e23), unconst_f32(0.3637), unconst_f32(0.2058))); |
| let vf53: vec2u = textureDimensions(tex17, unconst_i32(9080769)); |
| var vf54: f32 = out[unconst_u32(1747761166)]; |
| out = vec4f(location_6.rggr.xzzw.yywx.zwwz.bbaa); |
| vf51 |= bitcast<i32>(dot(vec2u(unconst_u32(391615208), unconst_u32(588363071)), vec2u(unconst_u32(225391473), unconst_u32(279647885)))); |
| var vf55: f32 = override18; |
| out = a7.location_10; |
| let vf56: i32 = override19; |
| var vf57: vec4f = a7.location_10; |
| return out; |
| _ = override18; |
| _ = override19; |
| _ = tex17; |
| } |
| |
| /* used global variables: buffer55, buffer59 */ |
| @fragment |
| fn fragment6(@builtin(position) position: vec4f, a1: FragmentInput10, a2: FragmentInput11) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| atomicCompareExchangeWeak(&buffer59.f0[u32(buffer55[arrayLength(&buffer55)][unconst_u32(1387946977)][unconst_u32(1132357614)][0][unconst_u32(1115309699)][0][unconst_u32(130536101)])].f0[u32((*&buffer55)[arrayLength(&(*&buffer55))][0][0][0][unconst_u32(268759485)][unconst_u32(1399846153)][12])][unconst_u32(1284196802)], unconst_i32(168913191), unconst_i32(8811784)); |
| let ptr41: ptr<storage, array<f16, 13>, read_write> = &buffer55[unconst_u32(1605491167)][0][0][unconst_u32(369261428)][0][unconst_u32(257292883)]; |
| for (var jj83=0u; jj83<3; jj83++) { buffer55[unconst_u32(141835753)][unconst_u32(153056707)][jj83][u32((*&buffer55)[arrayLength(&(*&buffer55))][0][u32((*&buffer55)[unconst_u32(372246688)][unconst_u32(208384818)][0][unconst_u32(558640983)][unconst_u32(10100056)][0][12])][unconst_u32(546112206)][0][0][12])][unconst_u32(1592451185)][unconst_u32(1324263618)][unconst_u32(137016334)] += (*&buffer55)[unconst_u32(358080265)][unconst_u32(136552830)][unconst_u32(2090570914)][0][0][0][12]; } |
| out.sample_mask -= u32(atomicLoad(&(*&buffer59).f0[arrayLength(&(*&buffer59).f0)].f0[0][0])); |
| let ptr42: ptr<storage, array<f16, 13>, read_write> = &buffer55[arrayLength(&buffer55)][0][0][0][unconst_u32(781082598)][0]; |
| let ptr43: ptr<storage, f16, read_write> = &buffer55[unconst_u32(68509761)][0][unconst_u32(125753025)][u32((*&buffer55)[arrayLength(&(*&buffer55))][unconst_u32(292127309)][unconst_u32(2020607008)][unconst_u32(116882561)][0][0][unconst_u32(1262911248)])][0][0][12]; |
| let ptr44: ptr<storage, array<array<f16, 13>, 1>, read_write> = &(*&buffer55)[unconst_u32(105144855)][unconst_u32(1560059449)][unconst_u32(801679577)][0][0]; |
| let ptr45: ptr<storage, f16, read_write> = &buffer55[arrayLength(&buffer55)][unconst_u32(301273361)][unconst_u32(761288597)][0][unconst_u32(31249302)][u32(buffer55[unconst_u32(68994447)][unconst_u32(21794441)][0][unconst_u32(887393088)][unconst_u32(517407486)][0][12])][12]; |
| out.sample_mask = u32((*&buffer55)[unconst_u32(2030395982)][unconst_u32(870707674)][unconst_u32(631198539)][0][0][0][12]); |
| out.location_3 &= vec2i(i32((*&buffer55)[arrayLength(&(*&buffer55))][0][unconst_u32(154616583)][unconst_u32(1752631702)][0][0][12])); |
| let ptr46: ptr<storage, f16, read_write> = &buffer55[arrayLength(&buffer55)][0][unconst_u32(808610617)][unconst_u32(73983373)][0][0][12]; |
| return out; |
| _ = buffer59; |
| _ = buffer55; |
| }`, |
| }); |
| let texture112 = device1.createTexture({ |
| size: [19, 20, 1785], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder24 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup0, new Uint32Array(4491), 755, 0); |
| } catch {} |
| try { |
| computePassEncoder14.end(); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(5, buffer32); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| textureView1.label = '\u71a1'; |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [{binding: 1, resource: {buffer: buffer49, size: 68}}], |
| }); |
| let renderPassEncoder3 = commandEncoder52.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: 198.3, g: -101.7, b: -834.6, a: 91.90, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 534307039, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup3, new Uint32Array(523), 121, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline5); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer47, 'uint32', 8, 4); |
| } catch {} |
| let commandEncoder57 = device1.createCommandEncoder({}); |
| let textureView65 = texture108.createView({}); |
| let renderBundleEncoder25 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| try { |
| device1.queue.submit([commandBuffer1]); |
| } catch {} |
| let imageData6 = new ImageData(8, 84); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let renderPassEncoder4 = commandEncoder14.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: -558.0, g: -561.8, b: -818.9, a: 74.86, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 185}, |
| maxDrawCount: 171505427, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(146), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer47, 'uint16', 56, 28); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'}); |
| } catch {} |
| let gpuCanvasContext4 = canvas1.getContext('webgpu'); |
| let commandEncoder59 = device1.createCommandEncoder({}); |
| let texture113 = device1.createTexture({ |
| size: [51, 1, 2], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture114 = device1.createTexture({ |
| size: {width: 39}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView66 = texture106.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer51, 124); }; |
| } catch {} |
| try { |
| computePassEncoder13.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer53, 'uint16', 88, 94); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 8, new Uint32Array(767).map((_, i) => i * 3), 6, 24); |
| } catch {} |
| let texture115 = device0.createTexture({ |
| size: [3395], |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float'], |
| }); |
| let renderPassEncoder5 = commandEncoder47.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: 50.60, g: -525.1, b: 844.8, a: 483.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 184562498, |
| }); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({ |
| label: '\uc430\u5282\u06bf\uc6e9\u9000', |
| colorFormats: ['rgba16float'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup5, new Uint32Array(1164), 19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer2); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| let sampler8 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 91.79}); |
| let texture116 = device0.createTexture({ |
| size: [1, 178, 1], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder0.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer48, 'uint32', 16, 0); |
| } catch {} |
| let pipeline8 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 972, new Float32Array(7839).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.039)), 23, 64); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| await gc(); |
| let shaderModule10 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| struct FragmentInput13 { |
| @location(10) @interpolate(perspective, centroid) location_10: vec2h, |
| @location(11) @interpolate(linear, sample) location_11: vec2f, |
| @location(2) location_2: vec4i, |
| @location(12) location_12: vec2f, |
| @location(6) location_6: vec4i, |
| @location(15) location_15: vec2h, |
| @location(14) location_14: f32, |
| @location(0) location_0: vec4i, |
| @location(8) location_8: f16, |
| } |
| |
| struct VertexInput32 { |
| @location(13) location_13: f32, |
| @location(11) location_11: i32, |
| @location(3) location_3: f32, |
| @location(8) location_8: vec2f, |
| } |
| |
| struct FragmentOutput6 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(0) location_0: vec4f, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentInput16 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct FragmentInput14 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| var<workgroup> vw24: atomic<i32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentInput12 { |
| @location(4) location_4: u32, |
| } |
| |
| struct VertexOutput2 { |
| @location(4) location_4: u32, |
| @location(3) location_3: i32, |
| @location(14) location_14: f32, |
| @location(6) location_6: vec4i, |
| @location(15) location_15: vec2h, |
| @location(2) location_2: vec4i, |
| @location(12) location_12: vec2f, |
| @location(11) @interpolate(linear, sample) location_11: vec2f, |
| @builtin(position) position: vec4f, |
| @location(10) @interpolate(perspective, centroid) location_10: vec2h, |
| @location(0) location_0: vec4i, |
| @location(8) location_8: f16, |
| } |
| |
| struct FragmentInput15 { |
| @builtin(position) position: vec4f, |
| } |
| |
| struct T0 { |
| @size(576) f0: atomic<u32>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex6(a0: VertexInput32, @location(12) location_12: vec4u, @location(15) location_15: f16, @location(0) @interpolate(linear, sample) location_0: vec4h, @location(14) @interpolate(flat, sample) location_14: vec4u) -> VertexOutput2 { |
| var out: VertexOutput2; |
| out.location_14 += out.position[1]; |
| var vf58: f32 = out.position[unconst_u32(937826735)]; |
| out.position = vec4f(f32(out.location_2[unconst_u32(279634358)])); |
| out.position -= vec4f(bitcast<f32>(out.location_4)); |
| out.location_14 = bitcast<f32>(out.location_15); |
| if bool(extractBits(vec3i(unconst_i32(194370817), unconst_i32(246021025), unconst_i32(11719217)), unconst_u32(267052962), unconst_u32(40621883)).z) { |
| let vf59: vec4f = tan(vec4f(unconst_f32(0.1085), unconst_f32(0.00639e-20), unconst_f32(-0.01841), unconst_f32(0.04689e5))); |
| let ptr47: ptr<function, f16> = &out.location_8; |
| let vf60: f16 = location_15; |
| loop { |
| var vf61: f32 = out.location_12[unconst_u32(27284939)]; |
| let vf62: vec2f = unpack2x16float(unconst_u32(646936541)); |
| return out; |
| break; |
| } |
| } |
| out.location_14 = out.position[0]; |
| var vf63: i32 = a0.location_11; |
| let vf64: i32 = out.location_2[unconst_u32(70111836)]; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment7(a0: FragmentInput12, @location(3) location_3: i32, a2: FragmentInput13, a3: FragmentInput14, @builtin(sample_mask) sample_mask: u32, a5: FragmentInput15, @builtin(sample_index) sample_index: u32) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| out.location_0 = unpack4x8snorm(a0.location_4); |
| var vf65: FragmentInput12 = a0; |
| out.location_0 = unpack4x8unorm(a0.location_4); |
| out.sample_mask -= bitcast<u32>(unpack2x16float(unconst_u32(379869122))[0]); |
| let ptr48: ptr<function, vec4f> = &out.location_0; |
| var vf66: f32 = a2.location_12[unconst_u32(340415405)]; |
| var vf67: vec2h = a2.location_15; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment8(@builtin(sample_index) sample_index: u32, @builtin(sample_mask) sample_mask: u32, a2: FragmentInput16) -> @location(200) vec4f { |
| var out: vec4f; |
| out = log2((mat2x3f(unconst_f32(0.3465e25), unconst_f32(0.03872e-44), unconst_f32(0.04431), unconst_f32(0.03405e4), unconst_f32(0.08301e3), unconst_f32(-0.00989)) * vec2f(unconst_f32(0.02019), unconst_f32(0.06863e0)))).yzyy; |
| let vf68: vec3u = extractBits(vec3u(acosh(vec3h(unconst_f16(10809.9), unconst_f16(3752.9), unconst_f16(15148.8)))), unconst_u32(624779808), unconst_u32(375244512)); |
| out -= vec4f(normalize(vec3h(unconst_f16(3936.9), unconst_f16(14506.7), unconst_f16(15781.2))).ggrb); |
| var vf69: f16 = tan(unconst_f16(24057.0)); |
| let vf70: vec3f = (mat2x3f(unconst_f32(0.07790), unconst_f32(0.00417), unconst_f32(0.2774), unconst_f32(0.4550), unconst_f32(0.03947), unconst_f32(0.02034)) * vec2f(unconst_f32(0.1088), unconst_f32(0.08964))); |
| var vf71: mat3x2f = (mat3x2f(trunc(vec3f(unconst_f32(0.03251), unconst_f32(0.08495e-27), unconst_f32(0.3000))).gb, trunc(vec3f(unconst_f32(0.03251), unconst_f32(0.08495e-27), unconst_f32(0.3000))).br, trunc(vec3f(unconst_f32(0.03251), unconst_f32(0.08495e-27), unconst_f32(0.3000))).br) * unconst_f32(0.3445e-26)); |
| out -= acos(vec4f(unconst_f32(0.1155e-6), unconst_f32(0.01189), unconst_f32(0.1280e5), unconst_f32(0.05458))); |
| var vf72: u32 = sample_mask; |
| return out; |
| }`, |
| }); |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 13, resource: textureView51}, |
| {binding: 103, resource: externalTexture4}, |
| {binding: 30, resource: {buffer: buffer49, size: 84}}, |
| {binding: 1, resource: textureView6}, |
| {binding: 9, resource: textureView5}, |
| ], |
| }); |
| let textureView67 = texture42.createView({}); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer49, 'uint16', 126, 10); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer48, 'uint16', 4, 10); |
| } catch {} |
| let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu'); |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let textureView68 = texture7.createView({baseArrayLayer: 0, arrayLayerCount: 1}); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: false, stencilReadOnly: true}); |
| let sampler9 = device1.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat', compare: 'equal'}); |
| let texture117 = device1.createTexture({ |
| size: {width: 156, height: 164, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView69 = texture91.createView({dimension: 'cube', aspect: 'all', baseMipLevel: 0}); |
| let computePassEncoder23 = commandEncoder22.beginComputePass(); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup0, new Uint32Array(1531), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup2, new Uint32Array(180), 47, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer53, 'uint16', 4, 141); |
| } catch {} |
| try { |
| buffer33.unmap(); |
| } catch {} |
| let texture118 = device0.createTexture({ |
| size: [1, 178, 1], |
| mipLevelCount: 2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder24 = commandEncoder37.beginComputePass(); |
| let renderPassEncoder6 = commandEncoder32.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: -971.6, g: 697.0, b: 743.2, a: -257.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer54, 'uint16', 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.insertDebugMarker('\u5015'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 1_932, new Float32Array(65536).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.028)), 13374, 268); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 212, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture10, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 9, resource: textureView5}, |
| {binding: 103, resource: externalTexture3}, |
| {binding: 13, resource: textureView51}, |
| {binding: 30, resource: {buffer: buffer49, size: 24}}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let textureView70 = texture16.createView({mipLevelCount: 1}); |
| let computePassEncoder25 = commandEncoder60.beginComputePass(); |
| let sampler10 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.99, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder24.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline4); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| commandEncoder29.insertDebugMarker('\ua368'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 4, new Uint32Array(16847).map((_, i) => i * 3), 1246, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 356, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 0, y: 51, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule11 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| struct T7 { |
| f0: u32, |
| } |
| |
| struct T2 { |
| @align(8) f0: array<u32>, |
| } |
| |
| struct ComputeInput19 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(0) var sam5: sampler; |
| |
| struct T1 { |
| f0: array<u32>, |
| } |
| |
| var<workgroup> vw25: vec4<bool>; |
| |
| struct T3 { |
| @align(64) @size(64) f0: array<vec4u, 1>, |
| f1: array<array<atomic<u32>, 1>>, |
| } |
| |
| struct T9 { |
| f0: array<u32>, |
| } |
| |
| var<private> vp4 = modf(vec3h(11621.4, -2291.0, 3541.6)); |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T8 { |
| @size(44) f0: atomic<u32>, |
| } |
| |
| struct T0 { |
| f0: array<atomic<u32>>, |
| } |
| |
| struct T4 { |
| f0: array<array<u32, 1>>, |
| } |
| |
| struct T13 { |
| @align(16) @size(64) f0: bool, |
| f1: array<u32>, |
| } |
| |
| struct T6 { |
| @align(32) f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct ComputeInput18 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct T10 { |
| @size(192) f0: mat4x2h, |
| f1: array<u32>, |
| } |
| |
| struct T5 { |
| f0: array<f32>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw26: atomic<i32>; |
| |
| struct T12 { |
| f0: vec4f, |
| } |
| |
| struct T11 { |
| @align(16) f0: array<f32>, |
| } |
| |
| /* used global variables: sam5 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute11(a0: ComputeInput18, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(global_invocation_id) global_invocation_id: vec3u, a3: ComputeInput19) { |
| while bool(length(unconst_f16(13336.9))) { |
| _ = sam5; |
| var vf73: u32 = local_invocation_index; |
| _ = sam5; |
| } |
| var vf74: u32 = pack4xI8Clamp(vec4i(unconst_i32(687090126), unconst_i32(289151699), unconst_i32(417257785), unconst_i32(8619421))); |
| let vf75: u32 = pack4xI8Clamp(vec4i(unconst_i32(-421976392), unconst_i32(142645894), unconst_i32(99613290), unconst_i32(358966676))); |
| _ = sam5; |
| vf74 += u32(unpack2x16float(bitcast<u32>(dot(vec2f(unconst_f32(0.1959e-21), unconst_f32(0.1462)), vec2f(unconst_f32(0.1158e-1), unconst_f32(0.2553)))))[1]); |
| atomicMax(&vw26, unconst_i32(27173238)); |
| vf74 += bitcast<vec4u>(pow(vec4f(unconst_f32(0.03863), unconst_f32(0.02515), unconst_f32(0.04143), unconst_f32(0.01244)), bitcast<vec4f>(global_invocation_id.xzyx.rgrb.ggaa.zzzw.zzxz))).g; |
| atomicXor(&vw26, unconst_i32(110600677)); |
| let vf76: u32 = global_invocation_id[unconst_u32(589977289)]; |
| vp4.whole = vec3h(unpack4xI8(unconst_u32(2462520503)).bgb); |
| atomicSub(&vw26, unconst_i32(328016076)); |
| _ = sam5; |
| }`, |
| }); |
| let autogeneratedBindGroupLayout4 = pipeline5.getBindGroupLayout(0); |
| let texture119 = device0.createTexture({size: [1697], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView71 = texture42.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let computePassEncoder26 = commandEncoder42.beginComputePass({ |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 77}, |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer54, 'uint16', 28, 10); |
| } catch {} |
| let imageData7 = new ImageData(48, 20); |
| try { |
| adapter1.label = '\u90ac'; |
| } catch {} |
| let textureView72 = texture98.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| let buffer61 = device1.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let texture120 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 11}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture121 = device1.createTexture({ |
| size: [102, 1, 29], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder23.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 18, y: 8, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 13, resource: textureView51}, |
| {binding: 1, resource: textureView6}, |
| {binding: 103, resource: externalTexture4}, |
| {binding: 30, resource: {buffer: buffer49, size: 120}}, |
| {binding: 9, resource: textureView5}, |
| ], |
| }); |
| let commandEncoder62 = device0.createCommandEncoder(); |
| let texture122 = device0.createTexture({ |
| size: [424, 1, 28], |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder17.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer10, 'uint32', 72, 62); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 1_348, new Uint32Array(15602).map((_, i) => i * 8), 1767, 208); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 178, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img0, |
| origin: { x: 61, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture94, |
| mipLevel: 0, |
| origin: {x: 0, y: 66, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout16 = device1.createBindGroupLayout({entries: [{binding: 93, visibility: GPUShaderStage.VERTEX, externalTexture: {}}]}); |
| let bindGroup14 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer50, size: 36}}, |
| {binding: 0, resource: textureView19}, |
| {binding: 98, resource: textureView21}, |
| ], |
| }); |
| let texture123 = device1.createTexture({ |
| size: [102, 1, 50], |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer51, 12); }; |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer30, 2_820, new Uint32Array(200).map((_, i) => i * 6), 20); |
| } catch {} |
| let buffer62 = device0.createBuffer({size: 96, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let textureView73 = texture31.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup6, new Uint32Array(494), 78, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer9, 'uint16', 2, 3); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer2); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline4); |
| } catch {} |
| let buffer63 = device1.createBuffer({size: 340, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder63 = device1.createCommandEncoder({}); |
| let texture124 = device1.createTexture({ |
| size: [156, 164, 232], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture125 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder27 = commandEncoder34.beginComputePass(); |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| let buffer64 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let texture126 = device0.createTexture({ |
| size: [3395, 1, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 52); }; |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup6, new Uint32Array(4819), 311, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup10, new Uint32Array(2952), 707, 0); |
| } catch {} |
| let shaderModule12 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| struct T2 { |
| @align(16) @size(32) f0: atomic<u32>, |
| @align(16) f1: array<atomic<u32>>, |
| } |
| |
| struct T0 { |
| @align(64) f0: array<vec2u>, |
| } |
| |
| struct T1 { |
| @align(64) f0: array<i32>, |
| } |
| |
| struct T3 { |
| @size(32) f0: array<atomic<i32>, 1>, |
| @align(16) f1: array<atomic<i32>>, |
| } |
| |
| @group(0) @binding(0) var sam6: sampler; |
| |
| struct ComputeInput20 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T5 { |
| f0: array<atomic<u32>>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T4 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp7 = modf(vec3h(8965.6, 1759.8, -3037.8)); |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput3 { |
| @location(10) location_10: vec4f, |
| @location(11) location_11: vec2u, |
| @location(6) @interpolate(perspective, sample) location_6: vec2h, |
| @location(12) @interpolate(flat, first) location_12: vec4u, |
| @location(5) location_5: vec2f, |
| @location(7) location_7: vec4f, |
| @location(3) location_3: f32, |
| @location(13) location_13: f16, |
| @invariant @builtin(position) position: vec4f, |
| @location(14) @interpolate(linear, first) location_14: vec2h, |
| @location(1) @interpolate(flat, first) location_1: vec4u, |
| @location(15) @interpolate(linear, centroid) location_15: vec2h, |
| @location(2) @interpolate(flat, sample) location_2: vec4u, |
| } |
| |
| var<private> vp6 = modf(f32(0.1639)); |
| |
| var<private> vp5 = array(array(frexp(f32(0.00479e-2))), array(frexp(f32(0.03467))), array(frexp(f32(0.07575e27))), array(frexp(f32(0.1013e24))), array(frexp(f32(0.1279))), array(frexp(f32(0.1588)))); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct VertexInput33 { |
| @location(10) location_10: vec2h, |
| @location(3) @interpolate(flat, either) location_3: vec2h, |
| @location(4) location_4: vec4h, |
| @location(9) @interpolate(linear) location_9: vec4h, |
| @location(14) location_14: vec2i, |
| @location(6) location_6: f16, |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex7(@location(5) @interpolate(flat, center) location_5: vec4i, @location(13) @interpolate(linear, centroid) location_13: vec4f, @location(15) location_15: f16, a3: VertexInput33, @location(12) @interpolate(flat) location_12: vec2h) -> VertexOutput3 { |
| var out: VertexOutput3; |
| for (var jj71=0u; jj71<8; jj71++) { vp5[jj71][unconst_u32(1560930348)].exp = bitcast<i32>(out.location_3); } |
| let ptr49: ptr<private, f32> = &vp6.fract; |
| let ptr50: ptr<function, vec2h> = &out.location_6; |
| out.location_10 = ceil(vec2f(unconst_f32(0.04257e-40), unconst_f32(-0.00967e-27))).grgr; |
| let ptr51 = &vp5[unconst_u32(1242715617)][0]; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(3, 3, 2) |
| fn compute12(a0: ComputeInput20) { |
| vp7 = modf(vp7.whole); |
| let ptr52: ptr<private, f32> = &vp6.fract; |
| let ptr53 = &vp7; |
| let ptr54: ptr<private, f32> = &(*ptr52); |
| vp6 = modf(bitcast<f32>(normalize(vec2h(unconst_f16(14250.3), unconst_f16(28905.3))))); |
| } |
| |
| /* used global variables: sam6 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute13(@builtin(num_workgroups) num_workgroups: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) { |
| _ = sam6; |
| var vf77: vec2h = degrees(vec2h(unconst_f16(4615.7), unconst_f16(16846.7))); |
| var vf78: vec4h = min(vec4h(unconst_f16(15637.0), unconst_f16(1909.0), unconst_f16(12253.7), unconst_f16(8289.0)), vec4h(unconst_f16(15321.8), unconst_f16(9029.8), unconst_f16(13216.8), unconst_f16(21947.9))); |
| let ptr55 = &vp5[5][0]; |
| switch bitcast<u32>(atan2(vec3f(unconst_f32(0.1066), unconst_f32(0.1791), unconst_f32(0.01225)), vec3f(unconst_f32(0.1606e-22), unconst_f32(0.1388), unconst_f32(0.4084))).x) { |
| default: { |
| for (var it2=bitcast<u32>(vp6.whole); it2<(vec4u(firstLeadingBit(vec4i(unconst_i32(411864603), unconst_i32(29200405), unconst_i32(444770206), unconst_i32(87150095))).aaag.yxzz.xyyz).g & 0xfff); it2++) { |
| { |
| var vf79: vec4h = asin(vec4h(unconst_f16(2401.0), unconst_f16(7671.0), unconst_f16(13912.9), unconst_f16(1028.9))); |
| vf79 = vec4h(f16(pack4xU8Clamp(vec4u(unconst_u32(736071130), unconst_u32(1242649513), unconst_u32(328762679), unconst_u32(110171862))))); |
| vp5[unconst_u32(50569971)][unconst_u32(636406363)] = frexp(bitcast<f32>(reflect(vec2h(unconst_f16(13963.5), unconst_f16(7813.0)), vec2h(unconst_f16(14625.0), unconst_f16(18562.4))))); |
| } |
| var vf80: vec3h = log(tanh(vec2h(unconst_f16(11908.5), unconst_f16(1876.3))).xxx); |
| let vf81: vec2f = unpack2x16snorm(bitcast<vec3u>(select(vec3f(unconst_f32(0.1507e-23), unconst_f32(0.1179), unconst_f32(0.3091)), vec3f(unconst_f32(0.04094e-3), unconst_f32(0.3889), unconst_f32(0.1857e-38)), unconst_bool(true)))[2]); |
| let ptr56: ptr<private, f32> = &vp5[unconst_u32(328390938)][unconst_u32(1449831696)].fract; |
| } |
| var vf82: vec4i = select(vec4i(unconst_i32(-369632615), unconst_i32(864594465), unconst_i32(475211942), unconst_i32(466162178)), vec4i(unconst_i32(700592475), unconst_i32(1097629135), unconst_i32(-627733359), unconst_i32(544281451)), vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(false))); |
| var vf83: vec4h = atanh(vec4h(f16(vp5[5][0].exp))); |
| break; |
| } |
| } |
| vf77 = bitcast<vec2h>(vp5[unconst_u32(2600758278)][0].fract); |
| let ptr57 = &vp7; |
| var vf84: vec4f = mix(unpack4x8snorm(unconst_u32(1008385685)), vec4f(unconst_f32(-0.03742e-6), unconst_f32(0.1212e38), unconst_f32(0.06180), unconst_f32(0.2986e30)), vec4f(unconst_f32(0.2477e-3), unconst_f32(0.3274), unconst_f32(0.1153), unconst_f32(0.06934))); |
| let ptr58: ptr<private, i32> = &vp5[5][0].exp; |
| _ = sam6; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute14(@builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) { |
| let ptr59: ptr<private, vec3h> = &vp7.whole; |
| var vf85: u32 = pack2x16float(vec2f(unconst_f32(0.01176e20), unconst_f32(0.00160e0))); |
| vp6 = modf(vp6.fract); |
| workgroupBarrier(); |
| vf85 >>= vec3u(cross(vec3f(unconst_f32(0.00881), unconst_f32(0.1728e-42), unconst_f32(0.2013e8)), vec3f(unconst_f32(0.1699), unconst_f32(0.1675), unconst_f32(0.2260))).bbb.yzy.brr).r; |
| vp5[unconst_u32(325306806)][unconst_u32(382461390)].fract = bitcast<f32>(workgroup_id[unconst_u32(297617761)]); |
| }`, |
| }); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let textureView74 = texture31.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup6, new Uint32Array(1756), 136, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 3395, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 0, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 31, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView75 = texture123.createView({arrayLayerCount: 1}); |
| let texture127 = device1.createTexture({ |
| size: {width: 320, height: 1, depthOrArrayLayers: 168}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer5, 0); }; |
| } catch {} |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer22, 0, 9); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame8 = new VideoFrame(offscreenCanvas3, {timestamp: 0}); |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let texture128 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 17}, |
| mipLevelCount: 2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView76 = texture84.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer7, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup10, new Uint32Array(2195), 418, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer64, 'uint16', 2, 4); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline4); |
| } catch {} |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup5, new Uint32Array(501), 14, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer8, 1_120); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup6, new Uint32Array(389), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setStencilReference(555); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup10, new Uint32Array(171), 38, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 1_856, new Float16Array(2700).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.847)), 529, 44); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 27} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 1, y: 13, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout17 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 24, hasDynamicOffset: false }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let textureView77 = texture113.createView({}); |
| let texture129 = device1.createTexture({ |
| size: {width: 640, height: 1, depthOrArrayLayers: 14}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let commandEncoder67 = device1.createCommandEncoder({}); |
| let renderPassEncoder7 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView63, |
| clearValue: { r: -662.2, g: 157.3, b: 48.12, a: -639.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture8 = device1.importExternalTexture({source: videoFrame8, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer53, 'uint32', 8, 71); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer32, 4); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer53, 'uint16', 28, 27); |
| } catch {} |
| document.body.prepend(canvas1); |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470bg', transfer: 'bt2020_12bit'} }); |
| try { |
| computePassEncoder16.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(1074), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer53, 'uint32', 12, 80); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer21, 0, 21); |
| } catch {} |
| try { |
| computePassEncoder19.insertDebugMarker('\u5a16'); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 103, resource: externalTexture1}, |
| {binding: 30, resource: {buffer: buffer62}}, |
| {binding: 13, resource: textureView51}, |
| {binding: 1, resource: textureView6}, |
| {binding: 9, resource: textureView5}, |
| ], |
| }); |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 89, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture68, |
| mipLevel: 4, |
| origin: {x: 0, y: 15, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline9 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule7, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule10, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 16, |
| attributes: [ |
| {format: 'float32x3', offset: 0, shaderLocation: 3}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint16x2', offset: 4, shaderLocation: 11}, |
| {format: 'uint32', offset: 0, shaderLocation: 12}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 15}, |
| {format: 'float32x2', offset: 4, shaderLocation: 13}, |
| {format: 'float32x2', offset: 0, shaderLocation: 0}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', unclippedDepth: true}, |
| }); |
| let commandEncoder68 = device0.createCommandEncoder(); |
| let textureView78 = texture12.createView({dimension: '2d-array', format: 'astc-4x4-unorm', mipLevelCount: 1}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame8}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer4, 'uint32', 0, 44); |
| } catch {} |
| try { |
| buffer54.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 13, resource: textureView51}, |
| {binding: 30, resource: {buffer: buffer62}}, |
| {binding: 9, resource: textureView68}, |
| {binding: 103, resource: externalTexture4}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let texture130 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer8); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(7, buffer46, 564); |
| } catch {} |
| try { |
| commandEncoder29.copyBufferToBuffer(buffer7, 24, buffer3, 32, 0); |
| } catch {} |
| document.body.append(canvas1); |
| let buffer65 = device1.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let texture131 = device1.createTexture({ |
| size: [102], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView79 = texture47.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup0, new Uint32Array(840), 70, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup2); |
| } catch {} |
| let texture132 = device1.createTexture({ |
| size: [102, 1, 67], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture133 = device1.createTexture({ |
| size: [408, 1, 65], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView80 = texture55.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder9.setVertexBuffer(2, buffer33); |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 294, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| {binding: 354, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let buffer66 = device1.createBuffer({size: 85, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder69 = device1.createCommandEncoder({}); |
| let texture134 = device1.createTexture({ |
| size: {width: 1280}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(4, buffer33, 48, 1); |
| } catch {} |
| let buffer67 = device1.createBuffer({size: 48, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder70 = device1.createCommandEncoder({}); |
| let texture135 = device1.createTexture({ |
| size: {width: 320, height: 1, depthOrArrayLayers: 5}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup2, new Uint32Array(2321), 83, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(601), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer53, 'uint16', 28, 16); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 52, new Uint32Array(16493).map((_, i) => i * 3), 7200, 0); |
| } catch {} |
| let buffer68 = device1.createBuffer({size: 216, usage: GPUBufferUsage.UNIFORM}); |
| let texture136 = device1.createTexture({ |
| size: [320], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView81 = texture134.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder1.setBlendConstant({ r: 387.2, g: -156.1, b: -440.1, a: -826.1, }); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer32, 'uint16', 4, 12); |
| } catch {} |
| let buffer69 = device1.createBuffer({size: 308, usage: GPUBufferUsage.UNIFORM}); |
| let texture137 = device1.createTexture({ |
| size: [204], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder7.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer32, 'uint32', 0, 78); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(6, buffer61, 0, 26); |
| } catch {} |
| let autogeneratedBindGroupLayout5 = pipeline6.getBindGroupLayout(2); |
| let bindGroup17 = device1.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 1, resource: {buffer: buffer50, size: 28}}], |
| }); |
| let commandEncoder71 = device1.createCommandEncoder({}); |
| let sampler11 = device1.createSampler({addressModeW: 'repeat', lodMaxClamp: 84.77, compare: 'always'}); |
| let textureView82 = texture131.createView({dimension: '1d'}); |
| let renderPassEncoder8 = commandEncoder70.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView80, |
| clearValue: { r: -158.6, g: -634.8, b: 439.6, a: 900.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 45752878, |
| }); |
| try { |
| renderPassEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer22, 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer53, 'uint32', 272, 22); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(1, buffer33, 24); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({device: device1, format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture114, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(175).fill(51), /* required buffer size: 175 */ |
| {offset: 175, bytesPerRow: 70, rowsPerImage: 43}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline10 = await device1.createComputePipelineAsync({label: '\u81cb\u{1fa24}\u1e5f\u7eb3', layout: 'auto', compute: {module: shaderModule6}}); |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 27} |
| */ |
| { |
| source: offscreenCanvas3, |
| origin: { x: 9, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 7, y: 2, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let textureView83 = texture20.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(7, buffer8); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 4, new DataView(new ArrayBuffer(71836)), 408, 0); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fcf8}\u0aa1'; |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| ], |
| }); |
| let buffer70 = device0.createBuffer({size: 120, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture138 = device0.createTexture({ |
| size: {width: 16, height: 16, depthOrArrayLayers: 27}, |
| mipLevelCount: 2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder28 = commandEncoder19.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 68); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer10, 'uint16', 104, 342); |
| } catch {} |
| try { |
| renderBundleEncoder14.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer71 = device0.createBuffer({size: 14144, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint']}); |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| computePassEncoder28.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(1, buffer46, 0, 229); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder24.pushDebugGroup('\u4113'); |
| } catch {} |
| let commandBuffer2 = commandEncoder20.finish(); |
| let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder28.setBindGroup(0, bindGroup10, new Uint32Array(2300), 746, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer48, 'uint16', 6, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 0, new Uint16Array(18036).map((_, i) => i + 3), 1485, 4); |
| } catch {} |
| let pipeline11 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule8, |
| constants: {override17: 1, override16: 1}, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'constant'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule7, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 632, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 388, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 96, shaderLocation: 8}, |
| {format: 'sint32x4', offset: 52, shaderLocation: 11}, |
| {format: 'sint32x3', offset: 24, shaderLocation: 13}, |
| {format: 'sint32', offset: 92, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 112, shaderLocation: 3}, |
| {format: 'snorm8x4', offset: 36, shaderLocation: 12}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 4}, |
| {format: 'float32x2', offset: 48, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 28, shaderLocation: 6}, |
| {format: 'uint8x4', offset: 8, shaderLocation: 10}, |
| {format: 'float32x2', offset: 64, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 196, shaderLocation: 5}, |
| {format: 'float16x2', offset: 56, shaderLocation: 14}, |
| {format: 'float32x2', offset: 40, shaderLocation: 15}, |
| ], |
| }, |
| {arrayStride: 12, attributes: [{format: 'unorm8x2', offset: 0, shaderLocation: 1}]}, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let canvas2 = document.createElement('canvas'); |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpteSt4281', transfer: 'bt1361ExtendedColourGamut'} }); |
| let commandEncoder73 = device1.createCommandEncoder({}); |
| let textureView84 = texture135.createView({dimension: '2d-array', arrayLayerCount: 2}); |
| let textureView85 = texture28.createView({aspect: 'stencil-only', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder4.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup18 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 0, resource: textureView19}, |
| {binding: 2, resource: {buffer: buffer50, size: 32}}, |
| {binding: 98, resource: textureView36}, |
| ], |
| }); |
| let commandEncoder74 = device1.createCommandEncoder({}); |
| let commandBuffer3 = commandEncoder12.finish(); |
| let texture139 = device1.createTexture({ |
| size: {width: 204}, |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup14, new Uint32Array(460), 59, 1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup18, new Uint32Array(405), 89, 1); |
| } catch {} |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let texture140 = device0.createTexture({size: [4], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let computePassEncoder29 = commandEncoder35.beginComputePass(); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup13, new Uint32Array(1952), 37, 0); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup7, new Uint32Array(3725), 211, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer8, 1_848); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer47, 'uint16', 44, 25); |
| } catch {} |
| try { |
| computePassEncoder24.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| adapter1.label = '\ubb9d\u050e\ubc91\u54e1\u{1ffa9}\u0f52\u7879\u{1facb}\u033b\u2082'; |
| } catch {} |
| let buffer72 = device0.createBuffer({size: 109, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let commandEncoder76 = device0.createCommandEncoder({}); |
| let texture141 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView86 = texture116.createView({arrayLayerCount: 1}); |
| let renderPassEncoder9 = commandEncoder7.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: 41.16, g: -691.7, b: -661.6, a: -90.13, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup6, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer49, 16); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer7, 8); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup12, new Uint32Array(428), 36, 0); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt709', transfer: 'hlg'} }); |
| let texture142 = device1.createTexture({ |
| size: {width: 19}, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup14, [0]); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline3); |
| } catch {} |
| let commandEncoder77 = device1.createCommandEncoder({}); |
| let texture143 = device1.createTexture({ |
| size: [408, 1, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView87 = texture64.createView({}); |
| let renderPassEncoder10 = commandEncoder15.beginRenderPass({colorAttachments: [{view: textureView57, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup14, new Uint32Array(253), 3, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer53, 'uint16', 4, 28); |
| } catch {} |
| let textureView88 = texture139.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(1, buffer22, 48); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 12, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture58, |
| mipLevel: 2, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let textureView89 = texture31.createView({baseArrayLayer: 0, arrayLayerCount: 1}); |
| let texture144 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 31}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView90 = texture98.createView({format: 'rgba16float', baseMipLevel: 0}); |
| let renderBundleEncoder32 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| let sampler12 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 67.59, |
| compare: 'not-equal', |
| }); |
| try { |
| renderPassEncoder5.draw(76, 2, 360_236_804, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer0, 12); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline9); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| let buffer73 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer0, 16); }; |
| } catch {} |
| try { |
| renderPassEncoder5.draw(25, 1, 550_341_867); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup16); |
| } catch {} |
| let gpuCanvasContext6 = canvas2.getContext('webgpu'); |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| externalTexture5.label = '\ucef2\uaad4\u7fed'; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup10, []); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer0, 12); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer10, 'uint16', 238, 16); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer73, 'uint32', 0, 11); |
| } catch {} |
| let textureView91 = texture137.createView({}); |
| let textureView92 = texture56.createView({aspect: 'all'}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer51, 52); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup8, new Uint32Array(1647), 3, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(4, buffer31, 0); |
| } catch {} |
| try { |
| commandEncoder10.copyBufferToBuffer(buffer63, 52, buffer30, 508, 20); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder80 = device0.createCommandEncoder(); |
| let texture145 = device0.createTexture({ |
| size: {width: 848}, |
| dimension: '1d', |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer49, 32); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer8, 1_112); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(3, bindGroup5, new Uint32Array(1110), 10, 0); |
| } catch {} |
| try { |
| commandEncoder78.resolveQuerySet(querySet1, 26, 2, buffer70, 0); |
| } catch {} |
| try { |
| computePassEncoder25.setBindGroup(2, bindGroup9, new Uint32Array(738), 488, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(198, 1, 469_120_374); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer46, 4, 353); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 80} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 6, y: 18 }, |
| flipY: false, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 3, y: 1, z: 21}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer74 = device1.createBuffer({label: '', size: 9189, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder81 = device1.createCommandEncoder({}); |
| let textureView93 = texture143.createView({}); |
| try { |
| renderBundleEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder11.insertDebugMarker('\u1dc5'); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 8, y: 51, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout6 = pipeline6.getBindGroupLayout(0); |
| let commandEncoder82 = device1.createCommandEncoder({}); |
| let texture146 = device1.createTexture({ |
| size: [78, 82, 24], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView94 = texture131.createView({arrayLayerCount: 1}); |
| let renderPassEncoder11 = commandEncoder59.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView57, |
| clearValue: { r: -601.8, g: -587.3, b: 822.8, a: -376.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let externalTexture10 = device1.importExternalTexture({source: videoFrame7}); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup0, new Uint32Array(1991), 1_270, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder21); computePassEncoder21.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder83 = device0.createCommandEncoder(); |
| let texture147 = device0.createTexture({ |
| size: [1697, 1, 1], |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup6, new Uint32Array(2883), 874, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer47, 60); }; |
| } catch {} |
| try { |
| renderPassEncoder5.draw(216, 1, 138_925_089, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer8, 812); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer73, 'uint32', 0, 4); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let bindGroup19 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView25}]}); |
| let buffer75 = device1.createBuffer({size: 48, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture148 = device1.createTexture({ |
| size: {width: 640, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView95 = texture89.createView({}); |
| let computePassEncoder30 = commandEncoder63.beginComputePass(); |
| try { |
| renderBundleEncoder19.setVertexBuffer(2, buffer61, 0); |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup20 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer71}}]}); |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let computePassEncoder31 = commandEncoder66.beginComputePass(); |
| try { |
| renderPassEncoder5.draw(41, 1, 427_920_441); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer47, 4); |
| } catch {} |
| try { |
| buffer73.unmap(); |
| } catch {} |
| let buffer76 = device0.createBuffer({size: 435, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let commandEncoder85 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer48, 'uint32', 0, 16); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| computePassEncoder29.setBindGroup(2, bindGroup5, new Uint32Array(407), 89, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer9, 'uint32', 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(1, buffer46); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer77 = device1.createBuffer({ |
| size: 8352, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder86 = device1.createCommandEncoder({}); |
| let renderPassEncoder12 = commandEncoder74.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView80, |
| clearValue: { r: -65.05, g: 722.3, b: 265.7, a: 563.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup19, new Uint32Array(619), 81, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer22, 140, 22); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer32, 'uint32', 4, 19); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(7, buffer32, 0, 34); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup21 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 0, resource: textureView25}, |
| {binding: 98, resource: textureView13}, |
| {binding: 2, resource: {buffer: buffer74, size: 208}}, |
| ], |
| }); |
| let commandBuffer4 = commandEncoder16.finish({}); |
| let texture149 = device1.createTexture({ |
| size: [51], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder32 = commandEncoder28.beginComputePass(); |
| try { |
| computePassEncoder30.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer32, 'uint16', 38, 8); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToBuffer({ |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 19, y: 16, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 4368 */ |
| offset: 4368, |
| bytesPerRow: 768, |
| buffer: buffer30, |
| }, {width: 3, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder86.insertDebugMarker('\u9d1f'); |
| } catch {} |
| let pipeline12 = await device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x7a3c2a08}, |
| fragment: { |
| module: shaderModule1, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| }], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 1084, shaderLocation: 8}, |
| {format: 'unorm16x2', offset: 140, shaderLocation: 0}, |
| {format: 'unorm16x2', offset: 320, shaderLocation: 10}, |
| {format: 'unorm16x2', offset: 744, shaderLocation: 2}, |
| {format: 'sint32', offset: 116, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 164, shaderLocation: 4}, |
| {format: 'sint32x2', offset: 136, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 172, shaderLocation: 9}, |
| {format: 'sint16x2', offset: 576, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 488, shaderLocation: 6}, |
| {format: 'float32x2', offset: 524, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 776, shaderLocation: 11}, |
| {format: 'float16x4', offset: 12, shaderLocation: 3}, |
| {format: 'float32x2', offset: 16, shaderLocation: 1}, |
| {format: 'uint32', offset: 1712, shaderLocation: 13}, |
| ], |
| }, |
| {arrayStride: 20, attributes: [{format: 'float32', offset: 0, shaderLocation: 15}]}, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16'}, |
| }); |
| let texture150 = device0.createTexture({ |
| label: '\u{1fed8}\u{1fa6e}', |
| size: [3395, 1, 132], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView96 = texture31.createView({ |
| label: '\u5ffa\ubd30\u3815\u0f8a\u{1fd31}\u5a52\uc8f6', |
| dimension: '2d-array', |
| mipLevelCount: 1, |
| arrayLayerCount: 1, |
| }); |
| try { |
| computePassEncoder31.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(159, 1, 70_501_981); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer47, 0); |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 952 widthInBlocks: 119 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 32 */ |
| offset: 32, |
| buffer: buffer48, |
| }, { |
| texture: texture33, |
| mipLevel: 1, |
| origin: {x: 28, y: 0, z: 5}, |
| aspect: 'all', |
| }, {width: 119, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12, new Float16Array(15707).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.609)), 1340, 4); |
| } catch {} |
| document.body.append(img0); |
| let veryExplicitBindGroupLayout20 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let computePassEncoder33 = commandEncoder86.beginComputePass(); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup19, new Uint32Array(160), 7, 0); |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| commandEncoder45.resolveQuerySet(querySet0, 27, 1, buffer50, 0); |
| } catch {} |
| try { |
| device1.queue.submit([commandBuffer4]); |
| } catch {} |
| let buffer78 = device0.createBuffer({size: 304, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder87 = device0.createCommandEncoder({label: '\u9b2a\u07a7\u0df4\u06c6\ub7bb'}); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline11); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'unspecified'} }); |
| let texture151 = device1.createTexture({ |
| size: {width: 1280, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup8, new Uint32Array(116), 5, 0); |
| } catch {} |
| try { |
| computePassEncoder21.end(); |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline2); |
| } catch {} |
| await gc(); |
| let texture152 = device0.createTexture({ |
| size: [424, 1, 32], |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundleEncoder34 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true}); |
| let sampler13 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 79.58, |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup3, new Uint32Array(1237), 687, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(7, 1, 148_272_374); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline11); |
| } catch {} |
| let buffer79 = device0.createBuffer({ |
| size: 280, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture153 = device0.createTexture({size: [2], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC}); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup11, new Uint32Array(3311), 340, 0); |
| } catch {} |
| try { |
| computePassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 294, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| {binding: 354, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let bindGroup22 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 294, resource: textureView79}, {binding: 354, resource: externalTexture10}], |
| }); |
| let commandEncoder88 = device1.createCommandEncoder(); |
| let renderPassEncoder13 = commandEncoder54.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView57, |
| clearValue: { r: -859.5, g: -313.6, b: -174.2, a: -360.2, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| let externalTexture12 = device1.importExternalTexture({source: videoFrame8}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer32, 'uint32', 8, 8); |
| } catch {} |
| let buffer80 = device0.createBuffer({size: 220, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup6, new Uint32Array(135), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(67, 1, 781_023_480, 1); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 20, new DataView(new ArrayBuffer(15993)), 635, 8); |
| } catch {} |
| document.body.prepend(img0); |
| let veryExplicitBindGroupLayout22 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| {binding: 4, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 14, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 39, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 78, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 124, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 160, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 161, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| {binding: 185, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 236, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 495, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder90 = device1.createCommandEncoder(); |
| let commandBuffer5 = commandEncoder18.finish(); |
| try { |
| renderPassEncoder12.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(2, buffer33); |
| } catch {} |
| try { |
| commandEncoder40.resolveQuerySet(querySet0, 30, 1, buffer50, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer23, 16, new BigInt64Array(282).map((_, i) => BigInt(i - 9)), 4, 0); |
| } catch {} |
| let promise4 = device1.queue.onSubmittedWorkDone(); |
| await gc(); |
| let commandBuffer6 = commandEncoder10.finish(); |
| let renderBundleEncoder35 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], stencilReadOnly: true}); |
| try { |
| renderPassEncoder8.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer53, 'uint32', 148, 36); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device1.queue.submit([commandBuffer5]); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 39, height: 41, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData5, |
| origin: { x: 4, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer81 = device1.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder91 = device1.createCommandEncoder(); |
| try { |
| renderPassEncoder11.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer33, 12); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup8, new Uint32Array(1183), 296, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer53, 'uint16', 44, 200); |
| } catch {} |
| let pipeline13 = await device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule6, constants: {}, targets: [{format: 'rgba16float'}]}, |
| vertex: { |
| module: shaderModule6, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x2', offset: 148, shaderLocation: 6}, |
| {format: 'snorm8x2', offset: 34, shaderLocation: 14}, |
| {format: 'sint16x4', offset: 244, shaderLocation: 3}, |
| {format: 'uint32', offset: 312, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 328, shaderLocation: 7}, |
| {format: 'unorm10-10-10-2', offset: 40, shaderLocation: 13}, |
| {format: 'uint32x3', offset: 236, shaderLocation: 15}, |
| ], |
| }, |
| { |
| arrayStride: 144, |
| attributes: [ |
| {format: 'unorm16x2', offset: 4, shaderLocation: 2}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 1}, |
| {format: 'uint16x4', offset: 28, shaderLocation: 0}, |
| {format: 'sint8x2', offset: 4, shaderLocation: 9}, |
| {format: 'float32x3', offset: 16, shaderLocation: 11}, |
| {format: 'sint32x3', offset: 16, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw'}, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer50, 0, 12); |
| } catch {} |
| try { |
| device1.queue.submit([commandBuffer6, commandBuffer3]); |
| } catch {} |
| let buffer82 = device0.createBuffer({size: 8, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture154 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 9}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer8, 1_000); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(2, buffer79); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderBundleEncoder34.setVertexBuffer(0, buffer8, 0, 334); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new DataView(new ArrayBuffer(25376)), 596, 4); |
| } catch {} |
| let buffer83 = device0.createBuffer({size: 172, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture155 = device0.createTexture({ |
| size: [1697], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer73, 8); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer8, 10_948); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer2, 0, 55); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToBuffer(buffer62, 0, buffer73, 8, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 12, new BigInt64Array(2585).map((_, i) => BigInt(i - 6)), 425, 0); |
| } catch {} |
| let commandEncoder92 = device1.createCommandEncoder({}); |
| let textureView97 = texture59.createView({}); |
| let renderPassEncoder14 = commandEncoder88.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView63, |
| clearValue: { r: 303.3, g: 393.8, b: 844.6, a: 744.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img0); |
| let commandBuffer7 = commandEncoder8.finish({}); |
| let computePassEncoder34 = commandEncoder69.beginComputePass(); |
| try { |
| computePassEncoder34.setPipeline(pipeline10); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 80, y: 53, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView98 = texture70.createView({}); |
| let texture156 = device1.createTexture({ |
| size: {width: 320, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup2, new Uint32Array(2854), 53, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer32, 0); |
| } catch {} |
| await gc(); |
| let textureView99 = texture74.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder5.drawIndirect(buffer0, 28); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer2, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 1_660, new Uint32Array(13918).map((_, i) => i * 9), 317, 136); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'smpte170m'} }); |
| let commandEncoder93 = device1.createCommandEncoder({}); |
| let textureView100 = texture113.createView({format: 'r32uint'}); |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup14, new Uint32Array(476), 75, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer61, 8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup1); |
| } catch {} |
| document.body.prepend(img1); |
| let videoFrame14 = videoFrame1.clone(); |
| let texture157 = device0.createTexture({size: [16, 16, 27], format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| try { |
| renderPassEncoder5.drawIndirect(buffer0, 8); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer4, 'uint32', 0, 2); |
| } catch {} |
| let pipeline14 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| let texture158 = device0.createTexture({ |
| size: {width: 16, height: 16, depthOrArrayLayers: 27}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1}); |
| try { |
| renderPassEncoder5.draw(324, 1, 950_937_359); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer47, 'uint16', 4, 27); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup3, []); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| offscreenCanvas3.width = 717; |
| let buffer84 = device1.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView101 = texture112.createView({format: 'r32uint', arrayLayerCount: 1}); |
| let renderPassEncoder15 = commandEncoder73.beginRenderPass({colorAttachments: [{view: textureView63, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer53, 'uint16', 64, 108); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer53, 'uint16', 46, 92); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer21); |
| } catch {} |
| try { |
| commandEncoder82.clearBuffer(buffer12); |
| } catch {} |
| try { |
| device1.queue.submit([commandBuffer7]); |
| } catch {} |
| let pipeline15 = await device1.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3}}); |
| let computePassEncoder35 = commandEncoder40.beginComputePass(); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup21, [768]); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer30, 2_340, new Uint32Array(931).map((_, i) => i * 10)); |
| } catch {} |
| let promise5 = device1.queue.onSubmittedWorkDone(); |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'smpteSt4281'} }); |
| let veryExplicitBindGroupLayout24 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer85 = device1.createBuffer({size: 142, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder94 = device1.createCommandEncoder({}); |
| let textureView102 = texture45.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let renderPassEncoder16 = commandEncoder93.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView63, |
| clearValue: { r: 14.87, g: -361.9, b: 160.6, a: -972.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder35.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(70); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup4, new Uint32Array(5107), 741, 0); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer23, 0, new Float32Array(9585).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.1660)), 624, 0); |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer80}}]}); |
| let commandEncoder95 = device0.createCommandEncoder({label: '\u297b\u07c1\u1834\u41b6\uf74b\u{1fa45}\u{1fa08}\u0279\ub288\u591f'}); |
| try { |
| renderPassEncoder4.setPipeline(pipeline11); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| await gc(); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer80, size: 76}}], |
| }); |
| let texture159 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder32.setVertexBuffer(5, buffer8, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer82, 4, new Uint32Array(2916).map((_, i) => i * 8), 485, 0); |
| } catch {} |
| let buffer86 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let commandBuffer8 = commandEncoder1.finish(); |
| let texture160 = device0.createTexture({ |
| size: [110, 790, 1], |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2, 2); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup18, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer32, 'uint16', 0, 15); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(1, buffer85, 0, 7); |
| } catch {} |
| try { |
| commandEncoder24.resolveQuerySet(querySet0, 80, 2, buffer85, 0); |
| } catch {} |
| let bindGroup25 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 9, resource: textureView68}, |
| {binding: 13, resource: textureView51}, |
| {binding: 30, resource: {buffer: buffer62}}, |
| {binding: 103, resource: externalTexture9}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let buffer87 = device0.createBuffer({size: 812, usage: GPUBufferUsage.VERTEX}); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup3); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'film', transfer: 'bt1361ExtendedColourGamut'} }); |
| let texture161 = device0.createTexture({ |
| size: [16, 16, 27], |
| format: 'r8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView103 = texture51.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer8, 480); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer73, 'uint32', 0, 63); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 0, resource: sampler1}]}); |
| let textureView104 = texture86.createView({dimension: 'cube-array', aspect: 'all', baseArrayLayer: 1, arrayLayerCount: 12}); |
| try { |
| commandEncoder58.resolveQuerySet(querySet1, 34, 35, buffer71, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 12, new DataView(new ArrayBuffer(17928)), 52, 0); |
| } catch {} |
| let buffer88 = device1.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let textureView105 = texture112.createView({aspect: 'all', baseMipLevel: 0}); |
| let promise6 = device1.queue.onSubmittedWorkDone(); |
| try { |
| await promise6; |
| } catch {} |
| let bindGroup27 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 62, resource: textureView18}, |
| {binding: 31, resource: externalTexture7}, |
| {binding: 138, resource: sampler3}, |
| {binding: 0, resource: sampler11}, |
| {binding: 1, resource: textureView62}, |
| {binding: 120, resource: textureView65}, |
| {binding: 16, resource: sampler7}, |
| {binding: 2, resource: textureView100}, |
| ], |
| }); |
| let commandEncoder96 = device1.createCommandEncoder({}); |
| try { |
| renderPassEncoder12.beginOcclusionQuery(199); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer22, 4); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup14, new Uint32Array(3133), 485, 1); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture29, |
| mipLevel: 1, |
| origin: {x: 2, y: 35, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(2_271).fill(105), /* required buffer size: 2_271 */ |
| {offset: 47, bytesPerRow: 92, rowsPerImage: 9}, {width: 4, height: 7, depthOrArrayLayers: 3}); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 7, y: 23, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout1 = pipeline4.getBindGroupLayout(0); |
| let bindGroup28 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer86}}]}); |
| let textureView106 = texture161.createView({dimension: '2d', format: 'r8uint', baseArrayLayer: 2}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer8, 712); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer10, 'uint16', 56, 113); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer87); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer10, 'uint16', 24, 32); |
| } catch {} |
| try { |
| renderPassEncoder3.insertDebugMarker('\u6820'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 27} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 7}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte432', transfer: 'hlg'} }); |
| let bindGroup29 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer79}}, |
| {binding: 13, resource: textureView104}, |
| {binding: 9, resource: textureView5}, |
| {binding: 103, resource: externalTexture11}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let texture162 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView107 = texture77.createView({baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder2.dispatchWorkgroupsIndirect(buffer7, 4); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer8, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline9); |
| } catch {} |
| try { |
| commandEncoder56.resolveQuerySet(querySet1, 52, 0, buffer71, 1024); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 36, new DataView(new Uint8Array(29814).map((_, i) => i).buffer), 14753, 8); |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({ |
| label: '\u8be7\u8b05\u{1fa67}\ua99c\ufc8f\u0787\u641e\u0125\u{1ff0e}\u0431', |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 9, resource: textureView68}, |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView104}, |
| {binding: 30, resource: {buffer: buffer71, size: 2856}}, |
| {binding: 103, resource: externalTexture11}, |
| ], |
| }); |
| let buffer89 = device0.createBuffer({size: 104, usage: GPUBufferUsage.VERTEX}); |
| let textureView108 = texture86.createView({dimension: 'cube-array', aspect: 'all', baseMipLevel: 0, baseArrayLayer: 11, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 1, -1_430_953_224); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer73, 'uint16', 16, 8); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline11); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(imageData3); |
| let commandEncoder97 = device1.createCommandEncoder(); |
| let texture163 = device1.createTexture({ |
| size: [640, 1, 5], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup0, new Uint32Array(2018), 331, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder35.setPipeline(pipeline3); |
| } catch {} |
| let texture164 = device1.createTexture({ |
| size: [256, 256, 243], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler14 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.28, |
| maxAnisotropy: 13, |
| }); |
| try { |
| device1.pushErrorScope('validation'); |
| } catch {} |
| try { |
| renderPassEncoder12.pushDebugGroup('\u4824'); |
| } catch {} |
| document.body.append(canvas2); |
| let externalTexture13 = device1.importExternalTexture({label: '\u74ca', source: videoFrame1}); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer53, 'uint32', 68, 98); |
| } catch {} |
| try { |
| renderBundleEncoder5.setPipeline(pipeline13); |
| } catch {} |
| let pipeline16 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| targets: [{ |
| format: 'rgba16float', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule9, |
| constants: {override19: 1}, |
| buffers: [ |
| { |
| arrayStride: 60, |
| attributes: [ |
| {format: 'uint32x2', offset: 4, shaderLocation: 4}, |
| {format: 'float32x4', offset: 4, shaderLocation: 3}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 5}, |
| {format: 'float16x4', offset: 4, shaderLocation: 7}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 14}, |
| {format: 'unorm8x2', offset: 12, shaderLocation: 13}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 11}, |
| {format: 'float32x2', offset: 0, shaderLocation: 12}, |
| {format: 'unorm16x2', offset: 8, shaderLocation: 10}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 0}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 15}, |
| {format: 'sint16x4', offset: 24, shaderLocation: 2}, |
| {format: 'snorm16x4', offset: 4, shaderLocation: 8}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 1}, |
| {format: 'uint32', offset: 36, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let bindGroup31 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer74, size: 1300}}, |
| {binding: 18, resource: textureView18}, |
| {binding: 1, resource: {buffer: buffer74, size: 724}}, |
| ], |
| }); |
| let buffer90 = device1.createBuffer({size: 186, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder98 = device1.createCommandEncoder({}); |
| let textureView109 = texture135.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| let texture165 = device1.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 29}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView110 = texture99.createView({label: '\u1208\u6db1\u0c6d\u{1fa7e}\u0e79', dimension: '2d'}); |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer32, 'uint16', 4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer32, 'uint16', 6, 12); |
| } catch {} |
| try { |
| renderBundleEncoder35.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(329).fill(201), /* required buffer size: 329 */ |
| {offset: 329, rowsPerImage: 21}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup4, new Uint32Array(2214), 931, 0); |
| } catch {} |
| try { |
| computePassEncoder33.pushDebugGroup('\u9a21'); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer49, 36); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer8, 3_044); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer54, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline9); |
| } catch {} |
| try { |
| commandEncoder79.clearBuffer(buffer7); |
| } catch {} |
| let buffer91 = device0.createBuffer({size: 58, usage: GPUBufferUsage.STORAGE}); |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth32float', depthReadOnly: true}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer49, 16); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(2, 0, 1, 312_134_665); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline9); |
| } catch {} |
| document.body.append(img1); |
| let bindGroup32 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer79}}, |
| {binding: 1, resource: textureView6}, |
| {binding: 103, resource: externalTexture2}, |
| {binding: 9, resource: textureView5}, |
| {binding: 13, resource: textureView104}, |
| ], |
| }); |
| let texture166 = device0.createTexture({ |
| size: [848, 1, 3], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(94, 1, 201_658_822, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer0, 8); |
| } catch {} |
| try { |
| renderPassEncoder6.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToTexture({ |
| texture: texture153, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 322, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 140, new Float32Array(11731).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.870)), 1646, 32); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer92 = device0.createBuffer({size: 272, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder101 = device0.createCommandEncoder(); |
| let texture167 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder5.draw(156, 1, 901_189_453); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer7, 16); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer7, 12); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup20, new Uint32Array(1390), 40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer78, 'uint16', 282, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer93 = device1.createBuffer({size: 276, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture168 = device1.createTexture({ |
| size: {width: 1280, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer81, 'uint32', 16, 25); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture58, |
| mipLevel: 1, |
| origin: {x: 9, y: 0, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 68, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 236, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 379, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView111 = texture108.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder15.setVertexBuffer(6, buffer31, 0, 23); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(6, buffer32, 4); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer94 = device1.createBuffer({size: 1780, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let commandEncoder102 = device1.createCommandEncoder({}); |
| let texture169 = device1.createTexture({ |
| size: {width: 156, height: 164, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView112 = texture24.createView({}); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup19, new Uint32Array(1922), 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer53, 'uint16', 72, 111); |
| } catch {} |
| offscreenCanvas0.height = 2267; |
| let commandEncoder103 = device1.createCommandEncoder(); |
| let computePassEncoder36 = commandEncoder92.beginComputePass(); |
| let externalTexture15 = device1.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup1, new Uint32Array(2646), 414, 0); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let bindGroup33 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout26, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer67}}, |
| {binding: 98, resource: textureView36}, |
| {binding: 0, resource: textureView15}, |
| ], |
| }); |
| let commandEncoder104 = device1.createCommandEncoder({}); |
| let textureView113 = texture56.createView({}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup21, [2048]); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup21, new Uint32Array(5), 0, 1); |
| } catch {} |
| try { |
| commandEncoder96.copyTextureToTexture({ |
| texture: texture104, |
| mipLevel: 0, |
| origin: {x: 200, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture105, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder14.insertDebugMarker('\u{1ffb3}'); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture146, |
| mipLevel: 0, |
| origin: {x: 2, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(1_469).fill(139), /* required buffer size: 1_469 */ |
| {offset: 17, bytesPerRow: 52, rowsPerImage: 4}, {width: 6, height: 4, depthOrArrayLayers: 7}); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 9, resource: textureView68}, |
| {binding: 13, resource: textureView104}, |
| {binding: 103, resource: externalTexture0}, |
| {binding: 30, resource: {buffer: buffer91, size: 24}}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let buffer95 = device0.createBuffer({size: 68, usage: GPUBufferUsage.STORAGE}); |
| let texture170 = device0.createTexture({ |
| size: [848, 1, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer8, 1_372); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 32, new DataView(new Uint8Array(39232).map((_, i) => i).buffer), 16170, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 27} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData8 = new ImageData(12, 132); |
| let autogeneratedBindGroupLayout7 = pipeline8.getBindGroupLayout(0); |
| let buffer96 = device0.createBuffer({size: 236, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| let texture171 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView114 = texture90.createView({dimension: '2d', baseArrayLayer: 2}); |
| try { |
| computePassEncoder29.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(162, 1, 195_578_459); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(2, buffer8); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| document.body.append(img0); |
| try { |
| externalTexture14.label = '\u0531\u{1fdbf}\u24b9\u64e8\u5392\u58d8\u0707\u{1fd50}\u0f4b'; |
| } catch {} |
| let autogeneratedBindGroupLayout8 = pipeline5.getBindGroupLayout(0); |
| let buffer97 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer9, 'uint32', 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(3, bindGroup10); |
| } catch {} |
| await gc(); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let computePassEncoder37 = commandEncoder85.beginComputePass(); |
| try { |
| computePassEncoder37.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(5, 303, 2, 212_142_575); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer92, 'uint16', 0, 16); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup16); |
| } catch {} |
| let pipeline17 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule8, |
| constants: {override16: 1, override17: 1}, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'src', dstFactor: 'src-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule7, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'sint32x4', offset: 516, shaderLocation: 11}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 8}, |
| {format: 'float32', offset: 688, shaderLocation: 12}, |
| {format: 'unorm8x4', offset: 420, shaderLocation: 15}, |
| {format: 'unorm16x4', offset: 28, shaderLocation: 14}, |
| {format: 'unorm16x2', offset: 400, shaderLocation: 1}, |
| {format: 'uint32', offset: 968, shaderLocation: 10}, |
| {format: 'float16x4', offset: 340, shaderLocation: 9}, |
| {format: 'uint8x4', offset: 200, shaderLocation: 5}, |
| {format: 'sint8x2', offset: 396, shaderLocation: 13}, |
| {format: 'uint32', offset: 544, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 368, shaderLocation: 0}, |
| {format: 'float32x4', offset: 460, shaderLocation: 7}, |
| {format: 'unorm8x4', offset: 196, shaderLocation: 6}, |
| {format: 'sint16x4', offset: 288, shaderLocation: 4}, |
| ], |
| }, |
| {arrayStride: 44, attributes: [{format: 'sint16x4', offset: 28, shaderLocation: 2}]}, |
| ], |
| }, |
| }); |
| let videoFrame18 = new VideoFrame(offscreenCanvas1, {timestamp: 0}); |
| let bindGroup35 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer95}}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer8, 180); }; |
| } catch {} |
| try { |
| renderBundleEncoder33.setPipeline(pipeline9); |
| } catch {} |
| let promise7 = shaderModule2.getCompilationInfo(); |
| try { |
| device0.queue.writeBuffer(buffer7, 12, new DataView(new ArrayBuffer(65084)), 845, 0); |
| } catch {} |
| let pipeline18 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| let imageData9 = new ImageData(4, 8); |
| let commandEncoder107 = device1.createCommandEncoder({}); |
| let externalTexture17 = device1.importExternalTexture({source: videoFrame12}); |
| try { |
| computePassEncoder35.setBindGroup(3, bindGroup0, new Uint32Array(313), 40, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup33, new Uint32Array(2936), 2_579, 1); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer22, 0, 35); |
| } catch {} |
| try { |
| commandEncoder107.copyBufferToBuffer(buffer52, 0, buffer30, 2320, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer31, 0, new Float32Array(648).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.677)), 6, 0); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let commandEncoder108 = device1.createCommandEncoder({}); |
| let texture172 = device1.createTexture({ |
| size: [320, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView115 = texture110.createView({mipLevelCount: 2}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(0); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer90); |
| } catch {} |
| try { |
| commandEncoder71.copyTextureToTexture({ |
| texture: texture149, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| document.body.prepend(img0); |
| try { |
| computePassEncoder27.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| renderBundleEncoder24.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(1, buffer85, 32, 11); |
| } catch {} |
| try { |
| commandEncoder96.copyTextureToTexture({ |
| texture: texture58, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 0, depthOrArrayLayers: 4}); |
| } catch {} |
| let pipeline19 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rgba16float', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex5', |
| constants: {override19: 1}, |
| buffers: [ |
| { |
| arrayStride: 72, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint8x2', offset: 28, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 6}, |
| {format: 'uint32x3', offset: 4, shaderLocation: 4}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 8}, |
| {format: 'sint8x2', offset: 12, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 28, shaderLocation: 3}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 0}, |
| {format: 'float16x2', offset: 4, shaderLocation: 13}, |
| {format: 'sint8x4', offset: 8, shaderLocation: 2}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 1}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 5}, |
| {format: 'float32x4', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| { |
| arrayStride: 64, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 4, shaderLocation: 10}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7}, |
| {format: 'sint32x3', offset: 24, shaderLocation: 15}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 13, resource: textureView108}, |
| {binding: 1, resource: textureView6}, |
| {binding: 9, resource: textureView68}, |
| {binding: 30, resource: {buffer: buffer79}}, |
| {binding: 103, resource: externalTexture6}, |
| ], |
| }); |
| let texture173 = device0.createTexture({ |
| size: [16, 16, 167], |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView116 = texture141.createView({dimension: '2d-array', format: 'rgb10a2uint', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| renderPassEncoder5.draw(4, 5, 2, 1_442_409_325); |
| } catch {} |
| try { |
| renderBundleEncoder34.setVertexBuffer(6, buffer89, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer32, 'uint16', 0, 33); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer22, 0); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 156, height: 164, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas2, |
| origin: { x: 20, y: 22 }, |
| flipY: false, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 45, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup37 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 103, resource: externalTexture6}, |
| {binding: 30, resource: {buffer: buffer71}}, |
| {binding: 13, resource: textureView108}, |
| {binding: 1, resource: textureView6}, |
| {binding: 9, resource: textureView68}, |
| ], |
| }); |
| let texture174 = device0.createTexture({ |
| size: [3395, 1, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder28.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(4, 309, 1, 100_930_882, 165_827_313); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer89); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| await gc(); |
| let commandEncoder109 = device1.createCommandEncoder({}); |
| let textureView117 = texture97.createView({}); |
| let computePassEncoder38 = commandEncoder46.beginComputePass(); |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup33, [0]); |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline10); |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup21, new Uint32Array(2001), 158, 1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup21, new Uint32Array(2575), 1_188, 1); |
| } catch {} |
| try { |
| renderBundleEncoder23.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder109.copyTextureToBuffer({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1200 */ |
| offset: 1200, |
| bytesPerRow: 768, |
| buffer: buffer30, |
| }, {width: 1, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 46, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(154).fill(192), /* required buffer size: 154 */ |
| {offset: 154, bytesPerRow: 176, rowsPerImage: 126}, {width: 15, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise8 = device1.queue.onSubmittedWorkDone(); |
| let buffer98 = device1.createBuffer({size: 404, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder110 = device1.createCommandEncoder(); |
| let computePassEncoder39 = commandEncoder34.beginComputePass(); |
| let renderBundle0 = renderBundleEncoder10.finish({}); |
| let sampler15 = device1.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest'}); |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup0, new Uint32Array(310), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setStencilReference(781); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer90, 0, 10); |
| } catch {} |
| let pipeline20 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, entryPoint: 'compute8'}}); |
| let bindGroup38 = device0.createBindGroup({layout: autogeneratedBindGroupLayout8, entries: [{binding: 0, resource: sampler0}]}); |
| let buffer99 = device0.createBuffer({size: 468, usage: GPUBufferUsage.INDIRECT}); |
| let textureView118 = texture173.createView({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer47, 16); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(5, 106, 0, 88_109_663, 192_182_123); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer47, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer47, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 500, new BigInt64Array(20966).map((_, i) => BigInt(i - 4)), 3537, 28); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer71}}]}); |
| let buffer100 = device0.createBuffer({size: 63, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let texture175 = device0.createTexture({ |
| size: {width: 4, height: 712, depthOrArrayLayers: 1}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView119 = texture90.createView({dimension: '2d', baseArrayLayer: 30}); |
| let computePassEncoder40 = commandEncoder44.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup37, []); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(4, 180, 0, 1_452_886_003, 100_417_762); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer9, 'uint16', 4, 5); |
| } catch {} |
| let buffer101 = device1.createBuffer({size: 4, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder111 = device1.createCommandEncoder({}); |
| let texture176 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 14}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder39.setPipeline(pipeline20); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let buffer102 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_DST}); |
| let textureView120 = texture175.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let textureView121 = texture80.createView({dimension: '2d'}); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup16, new Uint32Array(1968), 416, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer99, 20); }; |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup24, new Uint32Array(132), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer0, 36); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderBundleEncoder34.setIndexBuffer(buffer78, 'uint32', 24, 29); |
| } catch {} |
| try { |
| buffer73.unmap(); |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| let texture177 = device0.createTexture({ |
| size: {width: 1697}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView122 = texture166.createView({dimension: '3d', format: 'rgb10a2uint', mipLevelCount: 1}); |
| let renderPassEncoder17 = commandEncoder72.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: -386.4, g: 195.3, b: -101.4, a: -167.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup25, []); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer7, 8); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer92, 'uint32', 184, 1); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer4, 'uint32', 4, 9); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.prepend(img1); |
| let texture178 = device0.createTexture({ |
| size: {width: 16, height: 16, depthOrArrayLayers: 27}, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder41 = commandEncoder43.beginComputePass(); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup25, new Uint32Array(443), 71, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer99, 108); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer64, 'uint16', 0, 3); |
| } catch {} |
| let pipeline21 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7}}); |
| try { |
| await promise7; |
| } catch {} |
| let textureView123 = texture177.createView({aspect: 'all', baseArrayLayer: 0}); |
| let texture179 = device0.createTexture({ |
| size: [848, 1, 298], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup38, new Uint32Array(5668), 1_027, 0); |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 18, 0, 332_379_694); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(3, 116, 1, 727_994_461, 25_785_277); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer10, 'uint32', 24, 4); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer1, 'uint32', 52, 40); |
| } catch {} |
| try { |
| commandEncoder80.pushDebugGroup('\uf681'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer86, 8, new DataView(new Uint8Array(10661).map((_, i) => i).buffer), 2281, 0); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup40 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 9, resource: textureView68}, |
| {binding: 13, resource: textureView108}, |
| {binding: 1, resource: textureView6}, |
| {binding: 103, resource: externalTexture1}, |
| {binding: 30, resource: {buffer: buffer80}}, |
| ], |
| }); |
| let texture180 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 19}, |
| dimension: '2d', |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture181 = device0.createTexture({ |
| size: [848, 1, 7], |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup9, new Uint32Array(1673), 225, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(4, 55, 7, 2_147_483_647, 939_669_591); |
| } catch {} |
| let bindGroup41 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 103, resource: externalTexture4}, |
| {binding: 13, resource: textureView108}, |
| {binding: 1, resource: textureView6}, |
| {binding: 9, resource: textureView68}, |
| {binding: 30, resource: {buffer: buffer49, size: 24}}, |
| ], |
| }); |
| let texture182 = device0.createTexture({ |
| size: [1, 178, 1], |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture183 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 34}, |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer49, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup26, []); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup23, new Uint32Array(1469), 193, 0); |
| } catch {} |
| try { |
| commandEncoder112.clearBuffer(buffer79); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 424, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture184 = device0.createTexture({ |
| size: {width: 8, height: 1424, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView124 = texture12.createView({dimension: '2d-array', format: 'astc-4x4-unorm', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup35, new Uint32Array(1057), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer99, 188); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 136, new Float32Array(587).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.860)), 97, 8); |
| } catch {} |
| let bindGroup42 = device1.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 1, resource: {buffer: buffer67}}]}); |
| let commandEncoder113 = device1.createCommandEncoder({}); |
| let texture185 = device1.createTexture({ |
| size: {width: 408, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder42 = commandEncoder38.beginComputePass(); |
| try { |
| computePassEncoder42.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer61, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup27, new Uint32Array(1004), 128, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer98, 'uint16', 94, 164); |
| } catch {} |
| let commandEncoder114 = device1.createCommandEncoder({}); |
| let textureView125 = texture185.createView({dimension: '2d', baseMipLevel: 0}); |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer90, 8, 16); |
| } catch {} |
| try { |
| renderBundleEncoder35.setPipeline(pipeline19); |
| } catch {} |
| try { |
| buffer50.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let buffer103 = device1.createBuffer({size: 168, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder38.setBindGroup(0, bindGroup2, new Uint32Array(1409), 552, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup33, [0]); |
| } catch {} |
| try { |
| renderPassEncoder8.setStencilReference(270); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer53, 'uint16', 34, 20); |
| } catch {} |
| try { |
| device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer31, 12, new Uint16Array(3113).map((_, i) => i + 5), 159, 4); |
| } catch {} |
| try { |
| adapter1.label = '\u94fb\u07c2'; |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 9, resource: textureView5}, |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView104}, |
| {binding: 30, resource: {buffer: buffer49, size: 56}}, |
| {binding: 103, resource: externalTexture5}, |
| ], |
| }); |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let textureView126 = texture178.createView({dimension: '2d'}); |
| let texture186 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 1}, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView127 = texture171.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup35, new Uint32Array(2627), 157, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer73, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer47, 4); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer47, 12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 32, new BigInt64Array(23214).map((_, i) => BigInt(i - 5)), 4243, 0); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 0, resource: sampler0}]}); |
| let texture187 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 43}, |
| mipLevelCount: 2, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(1, buffer87, 144, 27); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup3, new Uint32Array(220), 151, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(2, buffer8, 0); |
| } catch {} |
| let textureView128 = texture110.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer81, 'uint32', 4, 1); |
| } catch {} |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'gamma28curve'} }); |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 9, resource: textureView5}, |
| {binding: 103, resource: externalTexture9}, |
| {binding: 13, resource: textureView108}, |
| {binding: 1, resource: textureView6}, |
| {binding: 30, resource: {buffer: buffer71}}, |
| ], |
| }); |
| let buffer104 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder116 = device0.createCommandEncoder(); |
| let textureView129 = texture138.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 9}); |
| let textureView130 = texture87.createView({dimension: '1d', arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 1_688_251_428, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer8, 5_788); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(2, buffer89, 0, 24); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 20, new DataView(new ArrayBuffer(51320)), 3185, 0); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let commandBuffer9 = commandEncoder47.finish(); |
| let texture188 = device0.createTexture({ |
| size: {width: 1697}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture189 = device0.createTexture({ |
| size: [2, 356, 57], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder43 = commandEncoder48.beginComputePass(); |
| let renderBundleEncoder38 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgb10a2unorm'], |
| depthStencilFormat: 'depth32float', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(1, bindGroup34, new Uint32Array(5413), 432, 0); |
| } catch {} |
| try { |
| computePassEncoder43.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer8, 2_108); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer99, 24); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder115.copyTextureToBuffer({ |
| texture: texture115, |
| mipLevel: 0, |
| origin: {x: 1085, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 15552 widthInBlocks: 1944 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1656 */ |
| offset: 1656, |
| buffer: buffer46, |
| }, {width: 1944, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer105 = device0.createBuffer({size: 40, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let textureView131 = texture186.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup32, new Uint32Array(631), 282, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer73, 16); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 0, new Uint16Array(5713).map((_, i) => i + 7), 4326, 8); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| { clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer90, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(7, buffer85, 40); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup18, [0]); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| let textureView132 = texture45.createView({dimension: '2d'}); |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(0, buffer88, 0); |
| } catch {} |
| try { |
| buffer50.unmap(); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToBuffer(buffer52, 12, buffer94, 172, 4); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(15).fill(221), /* required buffer size: 15 */ |
| {offset: 15, bytesPerRow: 157, rowsPerImage: 41}, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 74, hasDynamicOffset: true }, |
| }, |
| {binding: 6, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 86, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 114, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 121, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'bgra8unorm', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 146, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 210, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 250, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'float', multisampled: false }, |
| }, |
| {binding: 396, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| ], |
| }); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 9, resource: textureView5}, |
| {binding: 30, resource: {buffer: buffer80}}, |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView104}, |
| {binding: 103, resource: externalTexture18}, |
| ], |
| }); |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let textureView133 = texture82.createView({dimension: 'cube', format: 'rgba16float', baseArrayLayer: 4}); |
| let textureView134 = texture130.createView({}); |
| let renderPassEncoder18 = commandEncoder56.beginRenderPass({ |
| label: '', |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: 224.8, g: 913.8, b: -759.5, a: -390.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet1}, |
| maxDrawCount: 312756293, |
| }); |
| try { |
| renderPassEncoder9.draw(0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(6, buffer79, 0, 18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer86, 16, new Uint32Array(26077).map((_, i) => i * 2), 3418, 4); |
| } catch {} |
| let imageData10 = new ImageData(24, 80); |
| let textureView135 = texture188.createView({}); |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup9, new Uint32Array(2271), 49, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 287_201_879, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer7, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer7, 12); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer8); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder99.copyTextureToTexture({ |
| texture: texture67, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture67, |
| mipLevel: 1, |
| origin: {x: 81, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer86, 12, new Uint32Array(14337).map((_, i) => i * 8), 398, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup47 = device1.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer63}}]}); |
| let texture190 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView136 = texture176.createView({dimension: '3d'}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer51, 40); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup22, new Uint32Array(3769), 484, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer32, 'uint16', 10, 7); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| let texture191 = device0.createTexture({ |
| size: {width: 2, height: 356, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView137 = texture12.createView({dimension: '2d', mipLevelCount: 1}); |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer7, 36); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer73, 16); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer78, 'uint16', 92, 2); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(0, buffer89, 60, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(1, bindGroup35, new Uint32Array(419), 95, 0); |
| } catch {} |
| try { |
| buffer104.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer104, 8, new Uint32Array(2523).map((_, i) => i * 6), 255, 0); |
| } catch {} |
| let imageData11 = new ImageData(24, 16); |
| let textureView138 = texture173.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup10, new Uint32Array(195), 42, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 403_013_983); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer92, 'uint32', 12, 15); |
| } catch {} |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer47, 'uint32', 16, 6); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToBuffer(buffer62, 0, buffer105, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 24, new BigInt64Array(15892).map((_, i) => BigInt(i - 9)), 5918, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 10, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(361).fill(85), /* required buffer size: 361 */ |
| {offset: 361, bytesPerRow: 20}, {width: 0, height: 127, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline22 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule8, constants: {override16: 1, override17: 1}}}); |
| let imageData12 = new ImageData(48, 16); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup38, new Uint32Array(3311), 17, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup23, new Uint32Array(3229), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer87, 0, 116); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder121 = device1.createCommandEncoder(); |
| let textureView139 = texture185.createView({dimension: '2d', baseArrayLayer: 0}); |
| let texture192 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer67, 12, buffer30, 5092, 20); |
| } catch {} |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup3, []); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 494_243_360); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder40.pushDebugGroup('\ue099'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer82, 4, new BigInt64Array(40786).map((_, i) => BigInt(i - 6)), 5848, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture193 = device0.createTexture({ |
| size: [848, 1, 87], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer99, 12); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer99, 132); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(6, buffer8); |
| } catch {} |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer48, 'uint16', 16, 8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1697, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 48, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline23 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule8, |
| entryPoint: 'fragment5', |
| constants: {override17: 1, override16: 1}, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'dst-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule12, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 60, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x2', offset: 8, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 14, shaderLocation: 15}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 13}, |
| {format: 'sint32', offset: 24, shaderLocation: 14}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 56, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 4, shaderLocation: 4}, |
| {format: 'sint32', offset: 0, shaderLocation: 5}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 6}, |
| {format: 'float16x4', offset: 0, shaderLocation: 3}, |
| ], |
| }, |
| {arrayStride: 20, attributes: [{format: 'float16x2', offset: 4, shaderLocation: 12}]}, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true}, |
| }); |
| document.body.prepend(img0); |
| let textureView140 = texture135.createView({dimension: '2d'}); |
| let textureView141 = texture156.createView({dimension: '2d-array', format: 'rg32float', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer98, 'uint32', 40, 53); |
| } catch {} |
| try { |
| commandEncoder103.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 464 */ |
| offset: 464, |
| buffer: buffer77, |
| }, { |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'logSqrt'} }); |
| let autogeneratedBindGroupLayout9 = pipeline19.getBindGroupLayout(3); |
| let commandEncoder123 = device1.createCommandEncoder({}); |
| let textureView142 = texture50.createView({dimension: '2d-array', format: 'rgba16uint'}); |
| let texture194 = device1.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 12}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView143 = texture151.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer98, 'uint16', 60, 35); |
| } catch {} |
| let pipeline24 = await device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule9, |
| constants: {}, |
| targets: [{format: 'rgba16uint', writeMask: 0}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| constants: {override19: 1}, |
| buffers: [ |
| { |
| arrayStride: 28, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 15}, |
| {format: 'sint16x2', offset: 12, shaderLocation: 11}, |
| {format: 'sint32', offset: 4, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 12, shaderLocation: 1}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 8}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 4}, |
| {format: 'float16x2', offset: 4, shaderLocation: 13}, |
| {format: 'uint8x4', offset: 8, shaderLocation: 6}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 2}, |
| {format: 'float16x2', offset: 0, shaderLocation: 7}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 9}, |
| {format: 'float32x2', offset: 0, shaderLocation: 12}, |
| {format: 'uint32x4', offset: 8, shaderLocation: 0}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'front'}, |
| }); |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470m', transfer: 'smpte170m'} }); |
| let buffer106 = device1.createBuffer({ |
| size: 256, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer66, 0); }; |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpteRp431', transfer: 'hlg'} }); |
| let recycledExplicitBindGroupLayout2 = pipeline9.getBindGroupLayout(0); |
| let bindGroup48 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 13, resource: textureView108}, |
| {binding: 30, resource: {buffer: buffer91, size: 16}}, |
| {binding: 103, resource: externalTexture11}, |
| {binding: 9, resource: textureView5}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let textureView144 = texture34.createView({dimension: '2d-array'}); |
| let renderBundleEncoder39 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1, depthReadOnly: true}); |
| try { |
| computePassEncoder25.setBindGroup(3, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup20, new Uint32Array(3190), 134, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer8, 3_496); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer8, 0, 3_350); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer89, 0, 6); |
| } catch {} |
| try { |
| computePassEncoder29.insertDebugMarker('\u{1fadc}'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup49 = device1.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 0, resource: textureView29}]}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer67, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| document.body.append(canvas1); |
| let textureView145 = texture152.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 8}); |
| let renderPassEncoder19 = commandEncoder95.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: 563.4, g: 776.7, b: -778.9, a: 760.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 4294967295}, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 48_057_855); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer73, 4); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer99, 92); |
| } catch {} |
| try { |
| commandEncoder36.copyBufferToBuffer(buffer48, 36, buffer7, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer73, 20, new DataView(new ArrayBuffer(52720)), 2808, 0); |
| } catch {} |
| try { |
| adapter0.label = '\u01ba\u26be\u0b23\u{1ff97}\u05ca\u0d26\u0b4d\u03f6'; |
| } catch {} |
| let textureView146 = texture86.createView({baseArrayLayer: 5, arrayLayerCount: 4}); |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 1_017_810_752); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer76, 'uint16', 14, 32); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, buffer87, 0, 63); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup28); |
| } catch {} |
| let imageData13 = new ImageData(104, 8); |
| try { |
| computePassEncoder22.setBindGroup(3, bindGroup47, new Uint32Array(2589), 315, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| computePassEncoder38.end(); |
| } catch {} |
| try { |
| computePassEncoder42.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup18, new Uint32Array(2935), 134, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder22.insertDebugMarker('\ub6c4'); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 39, height: 41, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 2, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 14, y: 11, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer32, 'uint32', 12, 7); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(0, buffer94, 0, 126); |
| } catch {} |
| document.body.append(img1); |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'bt709'} }); |
| let bindGroup50 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 103, resource: externalTexture9}, |
| {binding: 9, resource: textureView68}, |
| {binding: 30, resource: {buffer: buffer71}}, |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView104}, |
| ], |
| }); |
| let texture195 = device0.createTexture({ |
| size: [4, 712, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder44 = commandEncoder50.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer8, 0, 5_077); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| try { |
| computePassEncoder28.insertDebugMarker('\u0d88'); |
| } catch {} |
| let imageData14 = new ImageData(28, 12); |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let textureView147 = texture87.createView({aspect: 'all'}); |
| let computePassEncoder45 = commandEncoder87.beginComputePass(); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame10}); |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup38, new Uint32Array(760), 138, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer0, 4); |
| } catch {} |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| commandEncoder80.popDebugGroup(); |
| } catch {} |
| let commandEncoder126 = device1.createCommandEncoder(); |
| let commandBuffer10 = commandEncoder46.finish(); |
| let renderBundleEncoder40 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float']}); |
| let sampler16 = device1.createSampler({addressModeV: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 96.45}); |
| try { |
| device1.queue.submit([commandBuffer10]); |
| } catch {} |
| let texture196 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView148 = texture50.createView({}); |
| let renderBundleEncoder41 = device1.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder14.setStencilReference(147); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer101, 'uint32', 0, 1); |
| } catch {} |
| try { |
| commandEncoder104.copyTextureToTexture({ |
| texture: texture165, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipelineLayout6 = device1.createPipelineLayout({ |
| bindGroupLayouts: [veryExplicitBindGroupLayout6, veryExplicitBindGroupLayout18, veryExplicitBindGroupLayout17, veryExplicitBindGroupLayout9], |
| }); |
| let buffer107 = device1.createBuffer({ |
| size: 112, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder127 = device1.createCommandEncoder({}); |
| let texture197 = device1.createTexture({ |
| size: [256], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView149 = texture151.createView({label: '\u5f60', mipLevelCount: 1}); |
| let computePassEncoder46 = commandEncoder102.beginComputePass(); |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(265), 25, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(0, buffer61, 0, 45); |
| } catch {} |
| let buffer108 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let textureView150 = texture2.createView({format: 'rgba16float'}); |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 12_706_611, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(1, bindGroup15, new Uint32Array(326), 131, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 4, height: 712, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 0, y: 205, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 1_027_693_339); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder32.setVertexBuffer(7, buffer89); |
| } catch {} |
| try { |
| buffer102.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 424, height: 1, depthOrArrayLayers: 14} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 11, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 106, y: 0, z: 6}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroup51 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 354, resource: externalTexture8}, {binding: 294, resource: textureView31}], |
| }); |
| let commandEncoder128 = device1.createCommandEncoder({}); |
| let textureView151 = texture62.createView({}); |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer81, 'uint32', 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer30, 6_456, new DataView(new Uint8Array(9444).map((_, i) => i).buffer), 68); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 51, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 10}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte170m', transfer: 'gamma22curve'} }); |
| let buffer109 = device0.createBuffer({size: 222, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let commandBuffer11 = commandEncoder17.finish(); |
| let computePassEncoder47 = commandEncoder76.beginComputePass(); |
| try { |
| computePassEncoder45.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup7, new Uint32Array(2840), 196, 0); |
| } catch {} |
| let texture198 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float'], |
| }); |
| try { |
| computePassEncoder47.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 117, 0, 1_768_089_290); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer7, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer46, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(1, bindGroup39, new Uint32Array(2599), 1_390, 0); |
| } catch {} |
| let commandEncoder130 = device1.createCommandEncoder({}); |
| let texture199 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer107, 'uint32', 8, 55); |
| } catch {} |
| try { |
| commandEncoder96.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 560 */ |
| offset: 560, |
| bytesPerRow: 5376, |
| buffer: buffer77, |
| }, { |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder90.clearBuffer(buffer23); |
| } catch {} |
| let bindGroup52 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout17, |
| entries: [{binding: 0, resource: {buffer: buffer67}}, {binding: 2, resource: {buffer: buffer74, size: 3124}}], |
| }); |
| let textureView152 = texture124.createView({baseMipLevel: 0}); |
| let externalTexture20 = device1.importExternalTexture({source: videoFrame7}); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer107, 'uint32', 8, 26); |
| } catch {} |
| try { |
| commandEncoder130.resolveQuerySet(querySet0, 12, 1, buffer66, 0); |
| } catch {} |
| try { |
| computePassEncoder46.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer53, 'uint16', 48, 25); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(2, buffer32); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 39, height: 41, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 6, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise11 = device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule9, |
| targets: [{format: 'rgba16uint'}, {format: 'rg32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 112, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 4, shaderLocation: 15}, |
| {format: 'sint32', offset: 40, shaderLocation: 5}, |
| {format: 'sint16x2', offset: 24, shaderLocation: 6}, |
| {format: 'sint8x4', offset: 8, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'float16x4', offset: 4, shaderLocation: 2}, |
| {format: 'snorm16x4', offset: 24, shaderLocation: 4}, |
| {format: 'uint32', offset: 24, shaderLocation: 13}, |
| ], |
| }, |
| { |
| arrayStride: 288, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x4', offset: 28, shaderLocation: 7}, |
| {format: 'sint8x4', offset: 116, shaderLocation: 8}, |
| {format: 'float16x2', offset: 24, shaderLocation: 1}, |
| {format: 'unorm10-10-10-2', offset: 68, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 40, shaderLocation: 14}, |
| {format: 'float16x2', offset: 56, shaderLocation: 0}, |
| {format: 'uint32', offset: 72, shaderLocation: 11}, |
| {format: 'float32', offset: 184, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front'}, |
| }); |
| let bindGroup53 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout17, |
| entries: [{binding: 0, resource: {buffer: buffer107}}, {binding: 2, resource: {buffer: buffer74, size: 1776}}], |
| }); |
| let buffer110 = device1.createBuffer({size: 19768, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let texture200 = device1.createTexture({ |
| size: [256, 256, 31], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView153 = texture92.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder46.setBindGroup(1, bindGroup51, new Uint32Array(556), 455, 0); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(0, bindGroup19, new Uint32Array(2738), 326, 0); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| let veryExplicitBindGroupLayout29 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 24, hasDynamicOffset: false }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let commandEncoder131 = device1.createCommandEncoder(); |
| let texture201 = device1.createTexture({ |
| size: [408], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView154 = texture45.createView({dimension: '2d-array'}); |
| let sampler17 = device1.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 89.41}); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup19, new Uint32Array(102), 31, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline16); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture58, |
| mipLevel: 1, |
| origin: {x: 10, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer111 = device0.createBuffer({size: 28, usage: GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder29.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer7, 4); |
| } catch {} |
| try { |
| renderBundleEncoder37.setIndexBuffer(buffer10, 'uint32', 84, 47); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(7, buffer87); |
| } catch {} |
| try { |
| commandEncoder120.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 111, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1952 widthInBlocks: 244 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2312 */ |
| offset: 2312, |
| rowsPerImage: 189, |
| buffer: buffer46, |
| }, {width: 244, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup54 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer80}}, |
| {binding: 13, resource: textureView104}, |
| {binding: 103, resource: externalTexture18}, |
| {binding: 9, resource: textureView5}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let commandEncoder132 = device0.createCommandEncoder(); |
| let textureView155 = texture175.createView({dimension: '2d-array', format: 'rgba32uint', arrayLayerCount: 1}); |
| let textureView156 = texture93.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer0, 20); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer79, 68, 35); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer64, 'uint32', 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(1, buffer87, 220, 164); |
| } catch {} |
| try { |
| commandEncoder35.insertDebugMarker('\u026a'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 0, new Uint32Array(7507).map((_, i) => i * 4), 1818, 8); |
| } catch {} |
| let textureView157 = texture183.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder48 = commandEncoder64.beginComputePass({ |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 146}, |
| }); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1, 1, 2); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer100, 'uint32', 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer89, 0, 27); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup3, new Uint32Array(833), 14, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(2, 73, 0, 200_980_972); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer109, 'uint16', 26, 33); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 0, y: 48, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(255).fill(37), /* required buffer size: 255 */ |
| {offset: 255, bytesPerRow: 149}, {width: 0, height: 53, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter1.label = '\u8cfb\u5b01\u{1f63b}\u7e25'; |
| } catch {} |
| let commandEncoder133 = device0.createCommandEncoder(); |
| let renderPassEncoder20 = commandEncoder89.beginRenderPass({ |
| colorAttachments: [{view: textureView122, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 239}, |
| }); |
| try { |
| computePassEncoder44.setBindGroup(2, bindGroup48, new Uint32Array(74), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer7, 4); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer92, 'uint16', 112, 2); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(1, buffer89, 72, 1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder100.clearBuffer(buffer3); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout27, |
| entries: [{binding: 2, resource: {buffer: buffer76, size: 124}}], |
| }); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let texture202 = device0.createTexture({ |
| size: {width: 4, height: 712, depthOrArrayLayers: 113}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup38, new Uint32Array(1614), 167, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer99, 148); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer73, 20); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline23); |
| } catch {} |
| try { |
| buffer111.unmap(); |
| } catch {} |
| try { |
| commandEncoder78.resolveQuerySet(querySet1, 59, 13, buffer71, 3072); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer79}}, |
| {binding: 103, resource: externalTexture3}, |
| {binding: 9, resource: textureView68}, |
| {binding: 13, resource: textureView104}, |
| {binding: 1, resource: textureView6}, |
| ], |
| }); |
| let buffer112 = device0.createBuffer({size: 137, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup44); |
| } catch {} |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer4, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(7, buffer112, 0); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer86, 0, new Uint32Array(16014).map((_, i) => i * 6), 1582, 0); |
| } catch {} |
| let textureView158 = texture122.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 5}); |
| try { |
| computePassEncoder48.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer73, 8); |
| } catch {} |
| try { |
| renderBundleEncoder0.insertDebugMarker('\ufecb'); |
| } catch {} |
| let pipeline25 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: {module: shaderModule7, targets: [{format: 'rgba16float', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule8, |
| entryPoint: 'vertex4', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 0, shaderLocation: 0}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 5}, |
| {format: 'float32', offset: 0, shaderLocation: 3}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 7}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 8}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 2}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 13}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 4}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'unorm8x4', offset: 364, shaderLocation: 14}, |
| {format: 'float16x2', offset: 4, shaderLocation: 15}, |
| {format: 'sint16x2', offset: 420, shaderLocation: 6}, |
| {format: 'unorm16x2', offset: 24, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let bindGroup57 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 103, resource: externalTexture6}, |
| {binding: 1, resource: textureView6}, |
| {binding: 30, resource: {buffer: buffer49, size: 20}}, |
| {binding: 13, resource: textureView104}, |
| {binding: 9, resource: textureView5}, |
| ], |
| }); |
| let textureView159 = texture86.createView({ |
| label: '\u3ba5\u0eea\ucd17\ucc9f\ua980\u01d0\u8785\uf66b\ue250\u09d2', |
| baseArrayLayer: 3, |
| arrayLayerCount: 1, |
| }); |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer7, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer99, 92); |
| } catch {} |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer9, 'uint32', 4, 1); |
| } catch {} |
| try { |
| commandEncoder106.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture77, |
| mipLevel: 1, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder20.insertDebugMarker('\u61ac'); |
| } catch {} |
| let bindGroup58 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout21, |
| entries: [{binding: 354, resource: externalTexture17}, {binding: 294, resource: textureView28}], |
| }); |
| let textureView160 = texture201.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer101, 'uint32', 0, 0); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer31, 12, new Float64Array(5497).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/5495)), 536, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout30 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| {binding: 59, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 139, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let renderPassEncoder21 = commandEncoder27.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView57, |
| clearValue: { r: -597.7, g: -474.7, b: 390.2, a: 269.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 73545525, |
| }); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup2, []); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup17, new Uint32Array(99), 15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(1, buffer85); |
| } catch {} |
| let shaderModule13 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| struct VertexOutput4 { |
| @location(0) @interpolate(flat, sample) location_0: vec4h, |
| @location(10) @interpolate(perspective) location_10: vec2h, |
| @location(6) location_6: vec4i, |
| @location(2) @interpolate(perspective, first) location_2: f32, |
| @location(8) location_8: u32, |
| @location(12) @interpolate(linear, centroid) location_12: vec2f, |
| @location(7) location_7: i32, |
| @location(1) @interpolate(flat, center) location_1: vec2i, |
| @location(11) location_11: vec4i, |
| @location(5) location_5: vec2i, |
| @location(3) @interpolate(flat, first) location_3: vec2f, |
| @location(9) @interpolate(flat) location_9: vec4u, |
| @location(13) location_13: vec4h, |
| @builtin(position) position: vec4f, |
| @location(4) @interpolate(flat, centroid) location_4: vec2i, |
| @location(14) @interpolate(perspective, sample) location_14: vec2h, |
| @location(15) location_15: vec2u, |
| } |
| |
| @group(0) @binding(16) var st13: texture_storage_2d_array<r32sint, read_write>; |
| |
| /* used global variables: sam8, tex18 */ |
| fn fn2() -> vec2<bool> { |
| var out: vec2<bool>; |
| out = vec2<bool>(vp8[unconst_u32(832105926)].whole.yz); |
| var vf92: vec2u = textureDimensions(tex18); |
| let vf93: u32 = override26; |
| let vf94: vec2i = (vec2i(unconst_i32(168221582), unconst_i32(645078143)) >> vec2u(unconst_u32(784197145), unconst_u32(767132373))); |
| vf92 = vec2u(vp8[3].fract.zz.xx); |
| vf92 += bitcast<vec2u>(textureSampleGrad(tex18, sam8, vec2f(unconst_f32(0.08723e-23), unconst_f32(0.6000e-42)), vec2f(unconst_f32(0.5140), unconst_f32(0.1593e-34)), vec2f(unconst_f32(0.2874e17), unconst_f32(0.3715))).xy); |
| return out; |
| _ = override26; |
| _ = tex18; |
| _ = sam8; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* used global variables: sam8 */ |
| @must_use |
| fn fn0(a0: texture_2d<f32>, a1: ptr<function, array<array<f16, 1>, 1>>) -> array<vec4h, 1> { |
| var out: array<vec4h, 1>; |
| let vf86: vec4<bool> = (vec4h(unconst_f16(1787.5), unconst_f16(-2236.9), unconst_f16(19308.9), unconst_f16(4935.6)) > vec4h(unconst_f16(-12116.2), unconst_f16(9663.1), unconst_f16(16400.7), unconst_f16(8279.1))); |
| let vf87: vec3i = firstTrailingBit(vec3i(unconst_i32(145564940), unconst_i32(658697161), unconst_i32(88327445))); |
| out[unconst_u32(55321925)] = vec4h(textureGather(3049878252 % 4, a0, sam8, vec2f(unconst_f32(0.1819e9), unconst_f32(0.02256)))); |
| let vf88: mat2x4h = (mat2x4h(unconst_f16(-24195.6), unconst_f16(314.6), unconst_f16(825.5), unconst_f16(7918.6), unconst_f16(24215.7), unconst_f16(9008.2), unconst_f16(18827.8), unconst_f16(23682.7)) * mat2x2h(unconst_f16(5378.0), unconst_f16(18403.9), unconst_f16(1489.4), unconst_f16(8577.6))); |
| return out; |
| _ = sam8; |
| } |
| |
| struct ComputeInput21 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| var<private> vp8 = array(modf(vec3f(0.09878e-38, 0.2676, 0.04346)), modf(vec3f(0.1351e18, 0.08071, 0.2495)), modf(vec3f(0.6335, 0.2326e-32, 0.1026e-23)), modf(vec3f(-0.1456e28, 0.4491, 0.03939))); |
| |
| struct VertexInput36 { |
| @location(6) location_6: vec2h, |
| @location(11) location_11: f32, |
| @location(4) location_4: vec2h, |
| @location(3) @interpolate(flat, center) location_3: vec2i, |
| @location(10) @interpolate(linear, sample) location_10: vec2f, |
| } |
| |
| struct VertexInput38 { |
| @location(12) location_12: vec2h, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct VertexInput34 { |
| @location(0) @interpolate(flat) location_0: vec4i, |
| } |
| |
| @group(1) @binding(0) var sam8: sampler; |
| |
| struct FragmentInput21 { |
| @location(0) @interpolate(flat, sample) location_0: vec4h, |
| } |
| |
| @id(8983) override override26: u32; |
| |
| struct FragmentInput19 { |
| @location(7) location_7: i32, |
| } |
| |
| struct T2 { |
| f0: array<array<array<array<bool, 1>, 1>, 1>>, |
| } |
| |
| struct FragmentOutput7 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(0) @interpolate(flat) location_0: vec4u, |
| @location(7) @interpolate(flat) location_7: vec2u, |
| } |
| |
| struct FragmentInput17 { |
| @invariant @builtin(position) position: vec4f, |
| @location(6) location_6: vec4i, |
| @location(1) @interpolate(flat, center) location_1: vec2i, |
| @location(15) location_15: vec2u, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| /* used global variables: sam8, tex18 */ |
| fn fn1() -> array<vec2h, 1> { |
| var out: array<vec2h, 1>; |
| { |
| vp8[unconst_u32(1719614510)].fract = vec3f(out[unconst_u32(1054123092)].xxx.xxy.ggg.rbr); |
| vp8[unconst_u32(421297187)] = vp8[unconst_u32(526357057)]; |
| let vf89: f16 = length(vec3h(unconst_f16(23658.8), unconst_f16(13770.1), unconst_f16(827.8))); |
| vp8[u32(saturate(vec3f(unconst_f32(0.01283), unconst_f32(0.1176e-42), unconst_f32(0.1292)))[0])].fract = vec3f(f32(pack2x16float(vec2f(unconst_f32(0.04636e14), unconst_f32(0.1470e-38))))); |
| } |
| let vf90: u32 = pack4xU8(vec4u(unconst_u32(309615500), unconst_u32(313548085), unconst_u32(441184373), unconst_u32(104011407))); |
| let ptr60: ptr<function, array<vec2h, 1>> = &out; |
| for (var jj79=0u; jj79<3; jj79++) { out[jj79] = vec2h(out[0][unconst_u32(157345829)]); } |
| vp8[unconst_u32(63715434)] = modf(vec3f(f32(override26))); |
| let vf91: vec4f = textureSampleGrad(tex18, sam8, vec2f(unconst_f32(0.1017), unconst_f32(0.1687)), vec2f(unconst_f32(0.02349e4), unconst_f32(0.04806e-9)), vec2f(unconst_f32(0.07945e-19), unconst_f32(0.1231))); |
| out[unconst_u32(560002301)] = vec2h((*ptr60)[0][unconst_u32(326776003)]); |
| return out; |
| _ = override26; |
| _ = sam8; |
| _ = tex18; |
| } |
| |
| var<private> vp9: vec4u = vec4u(468017230, 1770869621, 1306882354, 1128612659); |
| |
| var<workgroup> vw27: atomic<i32>; |
| |
| struct T1 { |
| @align(32) f0: array<u32>, |
| } |
| |
| struct T3 { |
| f0: array<array<vec4<bool>, 1>>, |
| } |
| |
| struct VertexInput37 { |
| @location(14) location_14: vec2i, |
| } |
| |
| struct T0 { |
| f0: array<vec4<bool>>, |
| } |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T4 { |
| @align(32) f0: array<u32>, |
| } |
| |
| @group(0) @binding(19) var<uniform> buffer113: array<array<vec4u, 203>, 2>; |
| |
| @group(0) @binding(20) var sam7: sampler; |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput35 { |
| @location(9) @interpolate(flat, sample) location_9: vec4u, |
| @location(1) location_1: vec4f, |
| } |
| |
| @group(0) @binding(0) var tex18: texture_2d<f32>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T6 { |
| f0: array<atomic<u32>>, |
| } |
| |
| struct FragmentInput18 { |
| @location(14) @interpolate(perspective, sample) location_14: vec2h, |
| @builtin(front_facing) front_facing: bool, |
| @builtin(sample_mask) sample_mask: u32, |
| @location(12) @interpolate(linear, centroid) location_12: vec2f, |
| @location(9) @interpolate(flat, center) location_9: vec4u, |
| @location(10) @interpolate(perspective, center) location_10: vec2h, |
| @location(13) location_13: vec4h, |
| @location(3) @interpolate(flat, first) location_3: vec2f, |
| } |
| |
| struct FragmentInput20 { |
| @location(4) @interpolate(flat, centroid) location_4: vec2i, |
| } |
| |
| /* used global variables: buffer113, sam8, tex18 */ |
| @vertex |
| fn vertex8(a0: VertexInput34, @location(15) location_15: vec2i, a2: VertexInput35, @location(5) @interpolate(flat) location_5: vec4u, @location(2) @interpolate(perspective) location_2: f32, @location(8) location_8: f16, @location(7) @interpolate(flat) location_7: vec2f, a7: VertexInput36, a8: VertexInput37, @location(13) location_13: vec2h, a10: VertexInput38, @builtin(instance_index) instance_index: u32, @builtin(vertex_index) vertex_index: u32) -> VertexOutput4 { |
| var out: VertexOutput4; |
| let ptr61: ptr<uniform, array<array<vec4u, 203>, 2>> = &(*&buffer113); |
| out.location_9 = bitcast<vec4u>(select(vec3f(unconst_f32(0.03714e24), unconst_f32(0.2844e-15), unconst_f32(0.07298)), vec3f(unconst_f32(0.07599e30), unconst_f32(-0.08460), unconst_f32(0.1484e-18)), vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false))).xyxy.rabb.brgr); |
| let ptr62: ptr<uniform, array<vec4u, 203>> = &buffer113[1]; |
| out.location_4 -= vec2i(select(vec3f(unconst_f32(0.04030), unconst_f32(0.1907), unconst_f32(0.05084e-35)), vec3f(unconst_f32(0.05800), unconst_f32(0.01344e-2), unconst_f32(0.00209e-21)), vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false))).yy); |
| vp9 <<= vec4u(a7.location_4.yxxy); |
| if bool(textureSampleGrad(tex18, sam8, vec2f(unconst_f32(0.09600e-8), unconst_f32(0.00526)), vec2f(unconst_f32(0.8399), unconst_f32(0.1533e14)), vec2f(unconst_f32(-0.02591), unconst_f32(0.5369e26)))[1]) { |
| let vf95: u32 = vertex_index; |
| return out; |
| } |
| var vf96: vec2h = a7.location_4; |
| fn2(); |
| return out; |
| _ = override26; |
| _ = sam8; |
| _ = tex18; |
| _ = buffer113; |
| } |
| |
| /* used global variables: buffer113, sam8, tex18 */ |
| @fragment |
| fn fragment9(@location(11) location_11: vec4i, @location(2) location_2: f32, a2: FragmentInput17, @builtin(sample_index) sample_index: u32, a4: FragmentInput18, @location(5) location_5: vec2i, a6: FragmentInput19, a7: FragmentInput20, a8: FragmentInput21, @location(8) location_8: u32) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| let ptr63: ptr<uniform, vec4u> = &(*&buffer113)[1][unconst_u32(321781230)]; |
| var vf97 = fn2(); |
| var vf98 = fn2(); |
| while bool(pack4xU8Clamp(vp9)) { |
| let ptr64: ptr<function, vec4u> = &out.location_0; |
| break; |
| } |
| return out; |
| _ = override26; |
| _ = sam8; |
| _ = tex18; |
| _ = buffer113; |
| } |
| |
| /* used global variables: sam7, sam8, st13, tex18 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute15(@builtin(global_invocation_id) global_invocation_id: vec3u, a1: ComputeInput21, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) { |
| if bool(textureGather(1582123240 % 4, tex18, sam7, vec2f(unconst_f32(0.08326e-23), unconst_f32(0.4191))).y) { |
| let vf99: u32 = pack4xU8Clamp(vec4u(unconst_u32(703567102), unconst_u32(107182204), unconst_u32(9383223), unconst_u32(1158222260))); |
| for (var it3=u32(transpose(mat3x2h(vec2h(vp8[3].fract.br.rg), vec2h(vp8[3].fract.zz.yy), vec2h(vp8[3].fract.rr)))[unconst_i32(0)].r); it3<(u32(all((vec2h(unconst_f16(6009.7), unconst_f16(-1394.0)) != vec2h(unconst_f16(3153.4), unconst_f16(4796.1))))) & 0xfff); it3++) { |
| vp8[pack4xU8(bitcast<vec4u>(textureSampleGrad(tex18, sam8, vec2f(unconst_f32(-0.3975e-13), unconst_f32(0.00217e24)), vec2f(unconst_f32(0.09121e-34), unconst_f32(0.1452e-3)), vec2f(unconst_f32(0.07666e0), unconst_f32(0.07799))).aara))] = modf(vec3f(sin(vec3h(unconst_f16(4874.1), unconst_f16(11279.6), unconst_f16(2018.8))))); |
| textureStore(st13, vec2i(unconst_i32(407006250), unconst_i32(213234037)), unconst_i32(-127239486), vec4i(vec4i(unconst_i32(557195362), unconst_i32(460574723), unconst_i32(227908240), unconst_i32(362979059)))); |
| return; |
| _ = sam8; |
| _ = st13; |
| _ = tex18; |
| } |
| textureStore(st13, vec2i(unconst_i32(442327822), unconst_i32(95947427)), unconst_i32(270996064), vec4i(vec4i(unconst_i32(142838145), unconst_i32(280315311), unconst_i32(196595683), unconst_i32(292111554)))); |
| vp8[pack4xU8(textureDimensions(tex18, unconst_i32(1429559892)).grrr)].whole = vec3f(vec3f(unconst_f32(0.3635e29), unconst_f32(0.2997), unconst_f32(0.1859e-20))); |
| var vf100: f16 = cosh(unconst_f16(22515.3)); |
| var vf101 = fn2(); |
| _ = override26; |
| _ = tex18; |
| _ = st13; |
| _ = sam8; |
| } |
| fn1(); |
| vp9 = bitcast<vec4u>(vp8[3].whole.xzzx); |
| switch vec4i(textureSampleBaseClampToEdge(tex18, sam7, vec2f(unconst_f32(0.06154), unconst_f32(0.2028e23))).bbgg.wzxy)[1] { |
| default { |
| _ = fn2(); |
| _ = override26; |
| _ = tex18; |
| _ = sam8; |
| } |
| } |
| atomicMin(&vw27, unconst_i32(403975138)); |
| textureStore(st13, vec2i(unconst_i32(1906546658), unconst_i32(1307546676)), unconst_i32(11517660), vec4i(vec4i(unconst_i32(202946297), unconst_i32(466099226), unconst_i32(76038009), unconst_i32(210768458)))); |
| _ = fn2(); |
| var vf102 = fn1(); |
| textureStore(st13, vec2i(unconst_i32(142127690), unconst_i32(840959088)), unconst_i32(439064915), vec4i(vec4i(unconst_i32(404019771), unconst_i32(53974161), unconst_i32(142314912), unconst_i32(611249979)))); |
| let ptr65: ptr<function, array<vec2h, 1>> = &vf102; |
| let vf103: vec4f = textureSampleLevel(tex18, sam8, vec2f(unconst_f32(0.3558), unconst_f32(0.05924)), unconst_f32(0.1334)); |
| _ = override26; |
| _ = st13; |
| _ = sam7; |
| _ = tex18; |
| _ = sam8; |
| }`, |
| }); |
| let bindGroup59 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: sampler8}]}); |
| let textureView161 = texture86.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup44, new Uint32Array(4106), 1_149, 0); |
| } catch {} |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer47, 20); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(1, buffer8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 178, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame20, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture94, |
| mipLevel: 0, |
| origin: {x: 0, y: 10, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer114 = device0.createBuffer({size: 56, usage: GPUBufferUsage.STORAGE, mappedAtCreation: true}); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let texture203 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 63}, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder28); computePassEncoder28.dispatchWorkgroupsIndirect(buffer8, 284); }; |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer108, 4); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer92, 'uint32', 20, 13); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(1, buffer79, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer86, 0, new Float16Array(1288).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.111)), 10, 16); |
| } catch {} |
| let buffer115 = device1.createBuffer({ |
| size: 16, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture204 = device1.createTexture({ |
| size: {width: 1280}, |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView162 = texture18.createView({dimension: '2d-array'}); |
| try { |
| renderBundleEncoder23.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder127.resolveQuerySet(querySet0, 9, 5, buffer5, 0); |
| } catch {} |
| let buffer116 = device1.createBuffer({size: 88, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder136 = device1.createCommandEncoder(); |
| let texture205 = device1.createTexture({ |
| size: [204, 1, 24], |
| mipLevelCount: 2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture206 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView163 = texture63.createView({}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup17, new Uint32Array(671), 79, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(1, bindGroup49, new Uint32Array(1339), 215, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(0, buffer85, 8); |
| } catch {} |
| try { |
| buffer67.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder12.popDebugGroup(); |
| } catch {} |
| let commandEncoder137 = device1.createCommandEncoder({}); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer53, 'uint16', 48, 46); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer81, 'uint16', 0, 18); |
| } catch {} |
| let texture207 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup40, new Uint32Array(292), 113, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder41); computePassEncoder41.dispatchWorkgroupsIndirect(buffer0, 16); }; |
| } catch {} |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder41.end(); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup13, new Uint32Array(933), 115, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(1, 0, 0, 260_140_976); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer108, 16); |
| } catch {} |
| try { |
| computePassEncoder40.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 8, new Float32Array(28116).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.312)), 9568, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer49, size: 64}}], |
| }); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 70, 0, 252_365_483); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(1, 0, 0, 2_116_110_142); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer89); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup24, new Uint32Array(2870), 513, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder133.clearBuffer(buffer79); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer117 = device1.createBuffer({ |
| size: 48, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder140 = device1.createCommandEncoder(); |
| let texture208 = device1.createTexture({ |
| size: [2560], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup21, [0]); |
| } catch {} |
| let computePassEncoder49 = commandEncoder108.beginComputePass(); |
| let renderPassEncoder22 = commandEncoder109.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView63, |
| clearValue: { r: -203.8, g: 396.4, b: 226.3, a: 413.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder49.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder13.setBlendConstant({ r: -412.3, g: 277.2, b: -317.6, a: -42.22, }); |
| } catch {} |
| try { |
| computePassEncoder33.popDebugGroup(); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| computePassEncoder40.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer109, 'uint32', 8, 20); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(6, buffer46); |
| } catch {} |
| try { |
| commandEncoder2.copyBufferToBuffer(buffer83, 24, buffer7, 4, 8); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer11]); |
| } catch {} |
| let bindGroup61 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout23, |
| entries: [ |
| {binding: 0, resource: textureView112}, |
| {binding: 2, resource: {buffer: buffer117}}, |
| {binding: 98, resource: textureView93}, |
| ], |
| }); |
| let textureView164 = texture148.createView({}); |
| let texture209 = device1.createTexture({ |
| label: '\u0a64\u{1fdc8}\u3b11\u380b\u020b\ufddf', |
| size: [256, 256, 12], |
| mipLevelCount: 5, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView165 = texture54.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup33, new Uint32Array(2676), 82, 1); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup2, new Uint32Array(1076), 93, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer23, 0, new Float32Array(586).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2998)), 21, 0); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 51, height: 1, depthOrArrayLayers: 26} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder141 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder42.setBindGroup(1, bindGroup1, new Uint32Array(874), 417, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup51, new Uint32Array(107), 13, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(6, buffer90, 0, 5); |
| } catch {} |
| try { |
| buffer93.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer75, 0, new Float32Array(3970).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.698)), 124, 0); |
| } catch {} |
| let bindGroup62 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [ |
| {binding: 1, resource: {buffer: buffer90, size: 12}}, |
| {binding: 0, resource: {buffer: buffer110}}, |
| {binding: 18, resource: textureView18}, |
| ], |
| }); |
| let querySet2 = device1.createQuerySet({type: 'occlusion', count: 124}); |
| let textureView166 = texture194.createView({dimension: 'cube', baseArrayLayer: 1}); |
| let texture210 = device1.createTexture({size: [256, 256, 181], dimension: '3d', format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup21, [1536]); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup52, new Uint32Array(2892), 1_848, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(3, bindGroup31, new Uint32Array(269), 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer98, 'uint16', 140, 65); |
| } catch {} |
| let bindGroup63 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 1, resource: {buffer: buffer107}}, |
| {binding: 18, resource: textureView17}, |
| {binding: 0, resource: {buffer: buffer74, offset: 0, size: 724}}, |
| ], |
| }); |
| let commandEncoder142 = device1.createCommandEncoder({}); |
| let textureView167 = texture23.createView({baseMipLevel: 0}); |
| let renderPassEncoder23 = commandEncoder96.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView102, |
| clearValue: { r: -50.75, g: 345.1, b: 578.3, a: 218.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder39.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(3, bindGroup18, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder35.setPipeline(pipeline3); |
| } catch {} |
| let imageData15 = new ImageData(84, 20); |
| let commandEncoder143 = device1.createCommandEncoder({}); |
| let querySet3 = device1.createQuerySet({type: 'occlusion', count: 199}); |
| try { |
| renderPassEncoder22.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup31); |
| } catch {} |
| try { |
| computePassEncoder16.insertDebugMarker('\ue49d'); |
| } catch {} |
| try { |
| renderPassEncoder8.insertDebugMarker('\u90f2'); |
| } catch {} |
| let texture211 = device0.createTexture({ |
| size: {width: 848, height: 1, depthOrArrayLayers: 25}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView168 = texture193.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer7, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer9, 'uint16', 4, 0); |
| } catch {} |
| try { |
| commandEncoder112.copyBufferToBuffer(buffer64, 0, buffer105, 16, 16); |
| } catch {} |
| document.body.append(canvas1); |
| let texture212 = device0.createTexture({size: [4, 712, 1], mipLevelCount: 3, format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup13, new Uint32Array(76), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 55, 0, 570_069_623); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer73, 16); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer46, 320, 1_656); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup10, new Uint32Array(5498), 214, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 424, height: 1, depthOrArrayLayers: 14} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 2, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderBundleEncoder42 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer8, 2_300); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(1, buffer2, 0, 113); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte170m', transfer: 'smpte170m'} }); |
| let bindGroup64 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout25, |
| entries: [ |
| {binding: 0, resource: textureView111}, |
| {binding: 379, resource: {buffer: buffer110, offset: 0}}, |
| {binding: 1, resource: textureView18}, |
| {binding: 6, resource: textureView97}, |
| {binding: 68, resource: textureView45}, |
| {binding: 174, resource: sampler3}, |
| {binding: 3, resource: {buffer: buffer81}}, |
| {binding: 236, resource: textureView47}, |
| ], |
| }); |
| let commandEncoder144 = device1.createCommandEncoder({}); |
| let texture213 = device1.createTexture({ |
| size: [19], |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView169 = texture62.createView({dimension: '3d'}); |
| let computePassEncoder50 = commandEncoder110.beginComputePass(); |
| try { |
| renderPassEncoder11.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(2, bindGroup62); |
| } catch {} |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 576 */ |
| offset: 576, |
| bytesPerRow: 31488, |
| rowsPerImage: 92, |
| buffer: buffer77, |
| }, { |
| texture: texture151, |
| mipLevel: 1, |
| origin: {x: 114, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 39, height: 41, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture15.label = '\u0070\u06e2\u08d7\u01c8\u0212'; |
| } catch {} |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup49); |
| } catch {} |
| try { |
| computePassEncoder50.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer116, 'uint16', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer117, 'uint32', 12, 10); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let bindGroup65 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 0, resource: sampler0}]}); |
| let buffer118 = device0.createBuffer({size: 700, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame16}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup39); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer47, 20); }; |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer54, 'uint16', 0, 11); |
| } catch {} |
| try { |
| renderBundleEncoder32.setVertexBuffer(4, buffer79); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup38, new Uint32Array(1503), 283, 0); |
| } catch {} |
| try { |
| computePassEncoder28.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(1, 0, 0, 795_586_299); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(2, bindGroup36, new Uint32Array(5460), 1_471, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer9, 'uint16', 4, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| await gc(); |
| let bindGroup66 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer79}}, |
| {binding: 13, resource: textureView108}, |
| {binding: 1, resource: textureView6}, |
| {binding: 103, resource: externalTexture2}, |
| {binding: 9, resource: textureView68}, |
| ], |
| }); |
| let buffer119 = device0.createBuffer({size: 34, usage: GPUBufferUsage.UNIFORM}); |
| let textureView170 = texture183.createView({format: 'r32sint', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 4}); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame15}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup24, new Uint32Array(277), 54, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer73, 8); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndirect(buffer7, 0); |
| } catch {} |
| try { |
| commandEncoder125.copyBufferToTexture({ |
| /* bytesInLastRow: 1120 widthInBlocks: 140 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 304 */ |
| offset: 304, |
| buffer: buffer118, |
| }, { |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 171, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 140, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new DataView(new ArrayBuffer(49236)), 755, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup67 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout0, entries: [{binding: 1, resource: {buffer: buffer108}}]}); |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| let textureView171 = texture174.createView({format: 'r32float'}); |
| let texture214 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView172 = texture167.createView({}); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup59, new Uint32Array(50), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, -987_246_902); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer8, 4_904); |
| } catch {} |
| try { |
| renderBundleEncoder16.draw(1, 1, 0, 1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let texture215 = device0.createTexture({ |
| size: {width: 16, height: 16, depthOrArrayLayers: 44}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView173 = texture16.createView({dimension: '3d', mipLevelCount: 1}); |
| let computePassEncoder51 = commandEncoder65.beginComputePass(); |
| try { |
| computePassEncoder37.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 265_331_558); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer99, 12); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndirect(buffer7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer73, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new DataView(new ArrayBuffer(15100)), 1285, 4); |
| } catch {} |
| let texture216 = device0.createTexture({ |
| size: {width: 8, height: 1424, depthOrArrayLayers: 41}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(136, 0, 823_434_764); |
| } catch {} |
| try { |
| renderBundleEncoder16.draw(1, 2); |
| } catch {} |
| try { |
| renderBundleEncoder16.drawIndexedIndirect(buffer99, 124); |
| } catch {} |
| try { |
| renderBundleEncoder38.setIndexBuffer(buffer1, 'uint16', 10, 113); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(251).fill(3), /* required buffer size: 251 */ |
| {offset: 251}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'logSqrt'} }); |
| let commandEncoder147 = device0.createCommandEncoder({}); |
| let commandBuffer12 = commandEncoder43.finish(); |
| let textureView174 = texture138.createView({label: '\u{1fcfa}\u4f58\u365b\ua230\u05cf\u6aa7\u{1fd4b}\ue064', dimension: 'cube', mipLevelCount: 1}); |
| let texture217 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let renderBundleEncoder43 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: false}); |
| let renderBundle1 = renderBundleEncoder16.finish({}); |
| let externalTexture23 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup10, new Uint32Array(529), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(256, 0, 587_368_990, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer8, 2_620); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer64, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture218 = device0.createTexture({ |
| size: {width: 1720, height: 176, depthOrArrayLayers: 1}, |
| format: 'astc-5x4-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView175 = texture174.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder52 = commandEncoder19.beginComputePass(); |
| let renderBundle2 = renderBundleEncoder3.finish({}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup20, []); |
| } catch {} |
| try { |
| computePassEncoder52.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer8); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer48, 'uint16', 2, 0); |
| } catch {} |
| let texture219 = device0.createTexture({ |
| size: [424, 1, 1339], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView176 = texture175.createView({dimension: '2d-array', aspect: 'all'}); |
| let computePassEncoder53 = commandEncoder100.beginComputePass(); |
| try { |
| computePassEncoder53.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer112, 0, 24); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(337).fill(0), /* required buffer size: 337 */ |
| {offset: 337, bytesPerRow: 45, rowsPerImage: 87}, {width: 0, height: 45, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer120 = device0.createBuffer({size: 105, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup13, new Uint32Array(2021), 740, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(0, 0, 0, 47_794_392); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer0, 16); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer8, 144); |
| } catch {} |
| try { |
| renderBundleEncoder37.setBindGroup(3, bindGroup37, []); |
| } catch {} |
| let textureView177 = texture86.createView({format: 'rgba32sint', baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder3.drawIndexed(0, 0, 0, 331_701_795); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer0, 0); |
| } catch {} |
| let commandEncoder149 = device1.createCommandEncoder({}); |
| let textureView178 = texture143.createView({}); |
| let texture220 = device1.createTexture({ |
| size: {width: 640, height: 1, depthOrArrayLayers: 75}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder24.setBindGroup(2, bindGroup27); |
| } catch {} |
| let commandEncoder150 = device1.createCommandEncoder({}); |
| let pipeline26 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule6, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'src', dstFactor: 'dst'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex5', |
| constants: {override19: 1}, |
| buffers: [ |
| { |
| arrayStride: 32, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint8x4', offset: 0, shaderLocation: 15}, |
| {format: 'float16x4', offset: 4, shaderLocation: 12}, |
| {format: 'sint32', offset: 4, shaderLocation: 14}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 6}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 5}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 8}, |
| {format: 'snorm16x2', offset: 20, shaderLocation: 3}, |
| {format: 'float32x2', offset: 0, shaderLocation: 13}, |
| {format: 'uint32', offset: 0, shaderLocation: 0}, |
| {format: 'float16x2', offset: 0, shaderLocation: 10}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 7}, |
| {format: 'sint8x2', offset: 8, shaderLocation: 2}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 1}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 4}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front'}, |
| }); |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let img2 = await imageWithData(20, 110, '#10101010', '#20202020'); |
| let buffer121 = device0.createBuffer({size: 464, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder151 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder47.setBindGroup(1, bindGroup65, new Uint32Array(270), 7, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer108, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup13, new Uint32Array(1333), 209, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(0, 0, 0, 304_918_838, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer7, 16); |
| } catch {} |
| try { |
| renderBundleEncoder43.setIndexBuffer(buffer105, 'uint32', 12, 2); |
| } catch {} |
| try { |
| renderBundleEncoder32.setPipeline(pipeline9); |
| } catch {} |
| try { |
| buffer72.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder152 = device1.createCommandEncoder({}); |
| let texture221 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView179 = texture194.createView({dimension: '2d', baseArrayLayer: 1, arrayLayerCount: 1}); |
| let externalTexture24 = device1.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup8, new Uint32Array(5446), 2_135, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(4, buffer33); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpte170m', transfer: 'iec6196624'} }); |
| let bindGroup68 = device1.createBindGroup({ |
| label: '\u7b91\u{1fba6}', |
| layout: veryExplicitBindGroupLayout26, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer110}}, |
| {binding: 98, resource: textureView13}, |
| {binding: 0, resource: textureView25}, |
| ], |
| }); |
| let commandEncoder153 = device1.createCommandEncoder(); |
| let sampler18 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer81, 'uint16', 26, 3); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer115, 0, new DataView(new ArrayBuffer(3992)), 291, 0); |
| } catch {} |
| document.body.prepend(canvas2); |
| let bindGroup69 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 294, resource: textureView79}, {binding: 354, resource: externalTexture15}], |
| }); |
| let commandEncoder154 = device1.createCommandEncoder({}); |
| let texture222 = device1.createTexture({ |
| size: [320, 1, 11], |
| mipLevelCount: 5, |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler19 = device1.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| renderPassEncoder13.setVertexBuffer(4, buffer31); |
| } catch {} |
| try { |
| renderBundleEncoder41.setVertexBuffer(2, buffer31, 8); |
| } catch {} |
| try { |
| commandEncoder144.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1344 */ |
| offset: 1344, |
| bytesPerRow: 5888, |
| rowsPerImage: 311, |
| buffer: buffer77, |
| }, { |
| texture: texture169, |
| mipLevel: 1, |
| origin: {x: 5, y: 7, z: 0}, |
| aspect: 'all', |
| }, {width: 15, height: 44, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 28, new Uint16Array(210).map((_, i) => i + 3), 2, 4); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 0, resource: sampler8}]}); |
| let commandEncoder155 = device0.createCommandEncoder({label: '\uaa8f\ub2d6\u90d7\u26d7\u{1f925}'}); |
| let texture223 = device0.createTexture({ |
| size: [848, 1, 37], |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder48.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderBundleEncoder36.setIndexBuffer(buffer92, 'uint32', 8, 111); |
| } catch {} |
| let arrayBuffer0 = buffer114.getMappedRange(); |
| try { |
| device0.queue.submit([commandBuffer12]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| let texture224 = device0.createTexture({ |
| size: {width: 424, height: 1, depthOrArrayLayers: 9}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView180 = texture175.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer99, 84); }; |
| } catch {} |
| try { |
| renderPassEncoder9.draw(47, 0, 126_358_929); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(0, 0, 0, -2_060_196_073); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer73, 4); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(1, buffer46, 20, 2_715); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 212, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 0, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture10, |
| mipLevel: 1, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let commandBuffer13 = commandEncoder44.finish({}); |
| let textureView181 = texture86.createView({format: 'rgba32sint', arrayLayerCount: 3}); |
| let computePassEncoder54 = commandEncoder112.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer0, 60); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer8, 532); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer112, 28); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndirect(buffer8, 7_408); |
| } catch {} |
| try { |
| commandEncoder84.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 564 */ |
| offset: 564, |
| bytesPerRow: 15872, |
| buffer: buffer118, |
| }, { |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 0, y: 15, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder20.insertDebugMarker('\u0de7'); |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 30, resource: {buffer: buffer95}}, |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView104}, |
| {binding: 9, resource: textureView68}, |
| {binding: 103, resource: externalTexture9}, |
| ], |
| }); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let texture225 = device0.createTexture({ |
| size: [1362, 12, 20], |
| mipLevelCount: 5, |
| format: 'astc-6x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture226 = device0.createTexture({ |
| size: {width: 848}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView182 = texture75.createView({format: 'rgba16sint'}); |
| try { |
| computePassEncoder54.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexedIndirect(buffer99, 16); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToBuffer(buffer48, 0, buffer104, 0, 8); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipeline27 = device0.createComputePipeline({layout: pipelineLayout4, compute: {module: shaderModule0, entryPoint: 'compute2'}}); |
| document.body.prepend(img0); |
| let imageBitmap2 = await createImageBitmap(videoFrame17); |
| let bindGroup72 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 18, resource: textureView17}, |
| {binding: 1, resource: {buffer: buffer50, size: 8}}, |
| {binding: 0, resource: {buffer: buffer74, size: 1932}}, |
| ], |
| }); |
| let commandEncoder158 = device1.createCommandEncoder({}); |
| let texture227 = device1.createTexture({ |
| size: [1280, 1, 485], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView183 = texture99.createView({baseMipLevel: 0}); |
| let sampler20 = device1.createSampler({mipmapFilter: 'linear', lodMaxClamp: 72.39}); |
| try { |
| renderPassEncoder22.beginOcclusionQuery(60); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer22); |
| } catch {} |
| try { |
| buffer77.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| let textureView184 = texture138.createView({dimension: 'cube-array', format: 'rgba16float', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer73, 4); |
| } catch {} |
| try { |
| renderBundleEncoder2.drawIndexedIndirect(buffer7, 24); |
| } catch {} |
| let commandEncoder160 = device1.createCommandEncoder({}); |
| let texture228 = device1.createTexture({ |
| size: [51], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| let computePassEncoder55 = commandEncoder77.beginComputePass(); |
| try { |
| computePassEncoder55.setPipeline(pipeline15); |
| } catch {} |
| document.body.append(canvas0); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup49, new Uint32Array(2803), 111, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer85, 0, 11); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let buffer122 = device1.createBuffer({size: 259, usage: GPUBufferUsage.STORAGE}); |
| try { |
| renderPassEncoder13.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(0, buffer22, 0, 99); |
| } catch {} |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer0, 12); }; |
| } catch {} |
| try { |
| renderPassEncoder9.draw(26, 0, 60_173_539); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer0, 24); |
| } catch {} |
| let autogeneratedBindGroupLayout10 = pipeline20.getBindGroupLayout(2); |
| let textureView185 = texture58.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 3}); |
| let renderPassEncoder24 = commandEncoder128.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView57, |
| clearValue: { r: 737.8, g: -626.9, b: 809.3, a: 492.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler21 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup51, []); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup68, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup47); |
| } catch {} |
| try { |
| commandEncoder98.copyTextureToTexture({ |
| texture: texture58, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 12}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 3, y: 5, z: 147}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| canvas1.height = 991; |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt2020', transfer: 'smpteSt4281'} }); |
| try { |
| adapter0.label = '\u0ab0\u067e\u{1f712}'; |
| } catch {} |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 61.79, |
| }); |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer47, 16); |
| } catch {} |
| try { |
| renderBundleEncoder30.setIndexBuffer(buffer112, 'uint16', 24, 3); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer123 = device1.createBuffer({size: 86, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder162 = device1.createCommandEncoder({}); |
| let renderPassEncoder25 = commandEncoder114.beginRenderPass({colorAttachments: [{view: textureView63, loadOp: 'load', storeOp: 'store'}]}); |
| let externalTexture25 = device1.importExternalTexture({source: videoFrame5}); |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup61, [0]); |
| } catch {} |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| let textureView186 = texture225.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1}); |
| let renderBundle3 = renderBundleEncoder2.finish({}); |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup59, new Uint32Array(136), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer47, 8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 308, new Float32Array(5831).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7787)), 1424, 120); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({ |
| label: '\u0034\u{1f6ab}\u387f', |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 103, resource: externalTexture2}, |
| {binding: 13, resource: textureView104}, |
| {binding: 30, resource: {buffer: buffer91, size: 16}}, |
| {binding: 1, resource: textureView6}, |
| {binding: 9, resource: textureView68}, |
| ], |
| }); |
| let texture229 = device0.createTexture({size: [8, 1424, 1], format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer0, 204); }; |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(3, bindGroup26, new Uint32Array(375), 82, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(330, 0, 1_290_989_166); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer8, 2_544); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(1, buffer87); |
| } catch {} |
| let textureView187 = texture135.createView({dimension: '2d', baseArrayLayer: 0}); |
| let texture230 = device1.createTexture({ |
| size: {width: 78, height: 82, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer32, 'uint16', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(6, buffer94, 108, 229); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 32, height: 32, depthOrArrayLayers: 12} |
| */ |
| { |
| source: videoFrame22, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture209, |
| mipLevel: 3, |
| origin: {x: 8, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData16 = new ImageData(76, 4); |
| let textureView188 = texture127.createView({dimension: '3d'}); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup42); |
| } catch {} |
| try { |
| renderBundleEncoder40.setBindGroup(3, bindGroup17); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: sampler1}]}); |
| let buffer124 = device0.createBuffer({size: 48, usage: GPUBufferUsage.UNIFORM}); |
| let commandBuffer14 = commandEncoder41.finish(); |
| let textureView189 = texture158.createView({dimension: 'cube-array', baseArrayLayer: 0, arrayLayerCount: 6}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup12, new Uint32Array(5219), 841, 0); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup55, new Uint32Array(720), 300, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer8, 864); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(0, bindGroup10, new Uint32Array(1148), 186, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder31.setIndexBuffer(buffer78, 'uint16', 8, 64); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14, commandBuffer13]); |
| } catch {} |
| let veryExplicitBindGroupLayout31 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 130, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 192, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 213, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 368, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 575, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let buffer125 = device1.createBuffer({size: 248, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder164 = device1.createCommandEncoder({}); |
| let texture231 = device1.createTexture({ |
| size: {width: 102}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup64, new Uint32Array(1945), 238, 0); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer31, 28, new Float32Array(1478).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.8319)), 136, 0); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 39, height: 41, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 1, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 25, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout32 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 68, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 174, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 236, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 379, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup75 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout31, |
| entries: [ |
| {binding: 13, resource: {buffer: buffer110}}, |
| {binding: 130, resource: textureView93}, |
| {binding: 368, resource: textureView140}, |
| {binding: 192, resource: textureView84}, |
| {binding: 575, resource: textureView91}, |
| {binding: 213, resource: textureView40}, |
| {binding: 0, resource: {buffer: buffer117}}, |
| ], |
| }); |
| let texture232 = device1.createTexture({ |
| size: {width: 78, height: 82, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView190 = texture230.createView({format: 'rgba16float'}); |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer101, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer22); |
| } catch {} |
| try { |
| buffer85.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer117, 4, new Float16Array(39149).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.08343)), 16053, 0); |
| } catch {} |
| let pipeline28 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule6, targets: [{format: 'rgba16float'}]}, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 48, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 0, shaderLocation: 9}, |
| {format: 'snorm16x4', offset: 4, shaderLocation: 7}, |
| {format: 'sint16x2', offset: 4, shaderLocation: 6}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 8}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 15}, |
| {format: 'sint32x3', offset: 8, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 8, shaderLocation: 1}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 14}, |
| {format: 'float32x2', offset: 0, shaderLocation: 2}, |
| {format: 'float16x4', offset: 4, shaderLocation: 10}, |
| {format: 'float32x2', offset: 8, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 11}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'front'}, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup74, new Uint32Array(75), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(0, 0, 0, 529_574_013); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline23); |
| } catch {} |
| try { |
| commandEncoder133.copyTextureToBuffer({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 460 */ |
| offset: 460, |
| bytesPerRow: 22272, |
| buffer: buffer46, |
| }, {width: 0, height: 78, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder79.copyTextureToTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 0, y: 108, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer118, 16, new Uint32Array(1358).map((_, i) => i * 1), 42, 4); |
| } catch {} |
| let commandEncoder165 = device1.createCommandEncoder({}); |
| let texture233 = device1.createTexture({ |
| label: '\u3d77\u{1fbbb}\u{1fb5a}\ud5bd\u08a0\u0ccf\u{1f6aa}', |
| size: [19, 20, 1], |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup63, []); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| try { |
| commandEncoder123.resolveQuerySet(querySet2, 3, 2, buffer125, 0); |
| } catch {} |
| let promise12 = device1.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {mask: 0x6e363c9e}, |
| fragment: { |
| module: shaderModule9, |
| constants: {}, |
| targets: [{ |
| format: 'rgba16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rg32float'}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| constants: {override19: 1}, |
| buffers: [ |
| { |
| arrayStride: 4, |
| attributes: [ |
| {format: 'uint16x2', offset: 0, shaderLocation: 9}, |
| {format: 'uint32', offset: 0, shaderLocation: 6}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 10}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 8}, |
| {format: 'float16x2', offset: 0, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 0}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 1}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 15}, |
| {format: 'sint32', offset: 0, shaderLocation: 14}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 2}, |
| {format: 'float32', offset: 0, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 124, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x2', offset: 16, shaderLocation: 5}, |
| {format: 'sint32x2', offset: 12, shaderLocation: 11}, |
| {format: 'uint32x3', offset: 40, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let bindGroup76 = device0.createBindGroup({layout: veryExplicitBindGroupLayout11, entries: [{binding: 1, resource: {buffer: buffer80}}]}); |
| let commandEncoder166 = device0.createCommandEncoder(); |
| let texture234 = device0.createTexture({ |
| size: [848, 1, 1], |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture235 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView191 = texture181.createView({aspect: 'all', mipLevelCount: 2, arrayLayerCount: 1}); |
| let renderBundle4 = renderBundleEncoder7.finish(); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 0, 0, 82_174_223); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer0, 28); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder31.setVertexBuffer(4, buffer46, 0); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer105, 0, new Uint32Array(7116).map((_, i) => i * 10), 1268, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| adapter1.label = '\u1199\u764f\u{1fd13}\u71e0\u0ece\u51d0\u0818\uf826\u{1fba4}\u74f2'; |
| } catch {} |
| let texture236 = device1.createTexture({ |
| size: {width: 640, height: 1, depthOrArrayLayers: 438}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView192 = texture63.createView({}); |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup69); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 19, height: 20, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame27, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture233, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture8.label = '\u{1fe3f}\u42ec\ue133\u7eb0\u0c3b\u0879\u{1fa74}\u4251'; |
| } catch {} |
| let textureView193 = texture204.createView({label: '\u0362\u{1f6d8}\u6268', dimension: '1d', baseMipLevel: 0}); |
| try { |
| renderPassEncoder22.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(5, buffer32); |
| } catch {} |
| try { |
| commandEncoder150.copyTextureToTexture({ |
| texture: texture146, |
| mipLevel: 0, |
| origin: {x: 0, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture172, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 32, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer110, 7_336, new Uint32Array(23607).map((_, i) => i * 4), 7176, 300); |
| } catch {} |
| let textureView194 = texture108.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder19.setBindGroup(3, bindGroup62); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer32, 'uint16', 20, 8); |
| } catch {} |
| try { |
| device1.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer65, 48, new Float32Array(20180).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.487)), 3557, 0); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(31); }; |
| } catch {} |
| let autogeneratedBindGroupLayout11 = pipeline1.getBindGroupLayout(0); |
| let bindGroup77 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [{binding: 354, resource: externalTexture8}, {binding: 294, resource: textureView31}], |
| }); |
| let commandEncoder167 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup58, new Uint32Array(604), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer53, 'uint32', 180, 61); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer21); |
| } catch {} |
| try { |
| buffer69.unmap(); |
| } catch {} |
| try { |
| commandEncoder127.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture135, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(2).fill(200), /* required buffer size: 2 */ |
| {offset: 2}, {width: 94, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 19, height: 20, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 78, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture233, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroup78 = device1.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 98, resource: textureView179}]}); |
| let renderBundleEncoder44 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float']}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline19); |
| } catch {} |
| try { |
| adapter0.label = '\u{1f65d}\u0f2f'; |
| } catch {} |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let renderPassEncoder26 = commandEncoder58.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView59, |
| clearValue: { r: -679.0, g: 715.6, b: -583.3, a: -964.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 261}, |
| }); |
| try { |
| computePassEncoder52.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(0, 0, 0, 30_882_928); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer0, 28); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer92, 'uint16', 14, 25); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(0, buffer79, 0, 1); |
| } catch {} |
| let commandEncoder169 = device1.createCommandEncoder(); |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer98, 'uint32', 20, 198); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(2, buffer33); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer101, 'uint32', 0, 0); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder170 = device1.createCommandEncoder({}); |
| let texture237 = device1.createTexture({ |
| size: {width: 204, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder56 = commandEncoder162.beginComputePass(); |
| try { |
| computePassEncoder49.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder56.setPipeline(pipeline15); |
| } catch {} |
| try { |
| buffer116.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer84, 8, new Float32Array(6372).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.689)), 1565, 0); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(videoFrame25); |
| let commandEncoder171 = device0.createCommandEncoder(); |
| let texture238 = device0.createTexture({ |
| size: [1697, 1, 88], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture239 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer47, 0); }; |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer0, 56); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer109, 'uint16', 122, 39); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(1, buffer46, 408, 297); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup34, new Uint32Array(215), 15, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.draw(46, 0, 507_183_169); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(12); }; |
| } catch {} |
| document.body.append(canvas2); |
| document.body.prepend(canvas0); |
| let buffer126 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView195 = texture3.createView({arrayLayerCount: 5}); |
| let texture240 = device0.createTexture({size: [848, 1, 15], format: 'depth32float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let textureView196 = texture202.createView({aspect: 'all', mipLevelCount: 1}); |
| let renderPassEncoder27 = commandEncoder168.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView122, |
| depthSlice: 1, |
| clearValue: { r: -679.8, g: 768.7, b: -393.9, a: -722.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 49450184, |
| }); |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(11, 0, 648_683_593); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(7, 262, 0, 482_490_510, 1_557_977_451); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(0, buffer89, 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder39.setVertexBuffer(3, buffer8); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup79 = device1.createBindGroup({layout: autogeneratedBindGroupLayout6, entries: [{binding: 2, resource: {buffer: buffer63}}]}); |
| let commandEncoder172 = device1.createCommandEncoder({}); |
| let textureView197 = texture110.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderBundleEncoder44.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(5, buffer61, 20); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| let commandEncoder173 = device1.createCommandEncoder({}); |
| let textureView198 = texture50.createView({}); |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer22, 0, 56); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(4, buffer88, 0, 30); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 3464 */ |
| offset: 3464, |
| bytesPerRow: 49920, |
| buffer: buffer77, |
| }, { |
| texture: texture232, |
| mipLevel: 1, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 32, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer30, 14_124, new DataView(new Uint8Array(7571).map((_, i) => i).buffer), 1030, 336); |
| } catch {} |
| document.body.append(canvas0); |
| try { |
| adapter1.label = '\u{1f64f}\u{1fd69}\ub937\u5648\u{1fa66}\uc114\u1131\ud2f3\u0139\u09d9'; |
| } catch {} |
| let commandEncoder174 = device1.createCommandEncoder({}); |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer32, 'uint32', 4, 10); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer65, 36, new DataView(new Uint8Array(32251).map((_, i) => i).buffer), 731, 4); |
| } catch {} |
| let imageData17 = new ImageData(12, 48); |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let textureView199 = texture182.createView({}); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup3, new Uint32Array(1913), 168, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer7, 28); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer10, 'uint16', 96, 9); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer47, 12); |
| } catch {} |
| try { |
| computePassEncoder24.insertDebugMarker('\u{1fc18}'); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexedIndirect(buffer73, 4); |
| } catch {} |
| try { |
| await shaderModule7.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 80} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 1, y: 6, z: 11}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView200 = texture39.createView({aspect: 'all', format: 'rgba16float', baseMipLevel: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer99, 56); }; |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndexed(2, 0, 0, 281_678_204); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer8, 7_080); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup45, new Uint32Array(783), 23, 0); |
| } catch {} |
| try { |
| buffer119.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let texture241 = device1.createTexture({ |
| size: [19, 20, 1], |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView201 = texture221.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup4, new Uint32Array(685), 229, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(0, buffer88); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture114, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(139).fill(31), /* required buffer size: 139 */ |
| {offset: 139, bytesPerRow: 245}, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpte240m', transfer: 'logSqrt'} }); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup74, new Uint32Array(722), 179, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 250, 0, 2_372_713_297); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(6, 322, 0, 761_688_802, 556_418_606); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer99, 32); |
| } catch {} |
| try { |
| renderBundleEncoder39.setBindGroup(1, bindGroup44); |
| } catch {} |
| try { |
| renderBundleEncoder22.draw(178, 0, 441_811_125); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer73, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 40, new BigInt64Array(19623).map((_, i) => BigInt(i - 9)), 1711, 8); |
| } catch {} |
| let bindGroup80 = device0.createBindGroup({layout: autogeneratedBindGroupLayout7, entries: [{binding: 0, resource: sampler0}]}); |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| let textureView202 = texture223.createView({aspect: 'depth-only', baseArrayLayer: 4, arrayLayerCount: 2}); |
| try { |
| computePassEncoder44.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(1, 0, 0, 56_411_675); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndexedIndirect(buffer47, 16); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer99, 12); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let pipeline29 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: {module: shaderModule7, targets: [{format: 'rgba16float'}]}, |
| vertex: { |
| module: shaderModule12, |
| entryPoint: 'vertex7', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| attributes: [ |
| {format: 'sint16x4', offset: 0, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 3}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 5}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 6}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 12}, |
| {format: 'float32x3', offset: 0, shaderLocation: 9}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 15}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let veryExplicitBindGroupLayout33 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| {binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 49, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 65, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 77, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 371, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture242 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder45 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], stencilReadOnly: true}); |
| try { |
| computePassEncoder56.setBindGroup(2, bindGroup1, new Uint32Array(1241), 303, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer117, 'uint32', 0, 2); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(1, buffer33, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(0, buffer32); |
| } catch {} |
| let commandEncoder178 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer8, 1_428); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer7, 32); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup74); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer108, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer105, 8, new Float32Array(2793).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.6947)), 230, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture183, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(1_857_383).fill(141), /* required buffer size: 1_857_383 */ |
| {offset: 87, bytesPerRow: 721, rowsPerImage: 161}, {width: 176, height: 0, depthOrArrayLayers: 17}); |
| } catch {} |
| let commandEncoder179 = device1.createCommandEncoder({}); |
| let sampler23 = device1.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.99, |
| compare: 'never', |
| }); |
| try { |
| { clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroupsIndirect(buffer115, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder21.insertDebugMarker('\u42e5'); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({layout: autogeneratedBindGroupLayout8, entries: [{binding: 0, resource: sampler1}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer73, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.drawIndirect(buffer47, 32); |
| } catch {} |
| try { |
| commandEncoder157.insertDebugMarker('\u02c6'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 4, new Float64Array(4038).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/4035)), 132, 8); |
| } catch {} |
| let bindGroup82 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 31, resource: externalTexture13}, |
| {binding: 120, resource: textureView65}, |
| {binding: 138, resource: sampler20}, |
| {binding: 0, resource: sampler23}, |
| {binding: 2, resource: textureView101}, |
| {binding: 16, resource: sampler17}, |
| {binding: 62, resource: textureView185}, |
| {binding: 1, resource: textureView62}, |
| ], |
| }); |
| let buffer127 = device1.createBuffer({size: 218, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let texture243 = device1.createTexture({ |
| size: [19], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup2, []); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline24); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture243, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(95).fill(138), /* required buffer size: 95 */ |
| {offset: 95}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer86}}]}); |
| let textureView203 = texture75.createView({}); |
| try { |
| renderPassEncoder9.draw(254, 0, 84_426_101); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(9, 39, 0, 383_479_704, 1_166_179_339); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer0, 140); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup39); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(2, buffer89, 0, 56); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 1, resource: textureView195}, |
| {binding: 13, resource: textureView104}, |
| {binding: 30, resource: {buffer: buffer49, size: 44}}, |
| {binding: 9, resource: textureView68}, |
| {binding: 103, resource: externalTexture23}, |
| ], |
| }); |
| let buffer128 = device0.createBuffer({size: 101, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| let commandBuffer15 = commandEncoder60.finish({}); |
| let texture244 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder4.drawIndirect(buffer99, 20); |
| } catch {} |
| try { |
| renderBundleEncoder22.draw(30, 0, 227_311_008); |
| } catch {} |
| try { |
| renderBundleEncoder32.setVertexBuffer(0, buffer2, 0, 1); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 1, resource: {buffer: buffer71}}]}); |
| let commandEncoder180 = device0.createCommandEncoder({}); |
| let textureView204 = texture98.createView({format: 'rgba16float', baseMipLevel: 0}); |
| let renderBundle5 = renderBundleEncoder22.finish(); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup60, new Uint32Array(3950), 1_063, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.drawIndirect(buffer73, 12); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(3, bindGroup80); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 27} |
| */ |
| { |
| source: img2, |
| origin: { x: 0, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| let renderBundleEncoder46 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint']}); |
| try { |
| computePassEncoder45.setBindGroup(1, bindGroup32, new Uint32Array(6491), 1_640, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.draw(62, 0, 4_294_967_233); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 0, 0, 53_593_609); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer9, 'uint32', 0, 6); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder32.setIndexBuffer(buffer4, 'uint16', 6, 5); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| let texture245 = device1.createTexture({ |
| size: {width: 320, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let texture246 = gpuCanvasContext0.getCurrentTexture(); |
| let sampler24 = device1.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'equal', |
| maxAnisotropy: 6, |
| }); |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup77); |
| } catch {} |
| let buffer129 = device0.createBuffer({ |
| size: 420, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let textureView205 = texture234.createView({}); |
| let texture247 = device0.createTexture({ |
| size: [4, 712, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup71); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer108, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup34, new Uint32Array(2623), 161, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle4, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(162, 0, 1_114_075_679); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer4, 'uint32', 4, 1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer129, 'uint16', 92, 43); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(4, buffer2, 8, 55); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer104, 8, new Float64Array(32830).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/32827)), 2831, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout34 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 155, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 56, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 264, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder182 = device1.createCommandEncoder({}); |
| let textureView206 = texture139.createView({}); |
| let textureView207 = texture220.createView({format: 'rgba16float', mipLevelCount: 1}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup33, [0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(7, buffer33, 4, 19); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| globalThis.someLabel = commandEncoder47.label; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer7, 0); }; |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 613, 0, 149_367_355); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer73, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer108, 28); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(2, bindGroup10, []); |
| } catch {} |
| try { |
| renderBundleEncoder42.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder180.copyBufferToBuffer(buffer129, 60, buffer104, 4, 12); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer15]); |
| } catch {} |
| document.body.append(canvas1); |
| let commandEncoder183 = device1.createCommandEncoder({}); |
| let textureView208 = texture131.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer81, 'uint32', 12, 4); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(2, buffer32, 4, 10); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup78); |
| } catch {} |
| offscreenCanvas0.height = 246; |
| let veryExplicitBindGroupLayout35 = device1.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 130, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 192, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 213, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 368, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 575, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let bindGroup86 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout17, |
| entries: [{binding: 0, resource: {buffer: buffer63}}, {binding: 2, resource: {buffer: buffer110, offset: 7680}}], |
| }); |
| let buffer130 = device1.createBuffer({size: 560, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture248 = device1.createTexture({ |
| label: '\u7301\u06af\u{1fdd2}\u09d0\u0399\u6f96\ub247\uca22\u1318', |
| size: {width: 102, height: 1, depthOrArrayLayers: 690}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup42, new Uint32Array(3866), 583, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(2, buffer94, 72); |
| } catch {} |
| let commandEncoder184 = device1.createCommandEncoder({}); |
| let textureView209 = texture194.createView({dimension: 'cube', baseArrayLayer: 0}); |
| try { |
| computePassEncoder46.setBindGroup(1, bindGroup78, new Uint32Array(301), 35, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer115, 8, new DataView(new ArrayBuffer(94300)), 19, 0); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup87 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [{binding: 354, resource: externalTexture24}, {binding: 294, resource: textureView31}], |
| }); |
| let commandEncoder185 = device1.createCommandEncoder({}); |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup47, new Uint32Array(383), 81, 0); |
| } catch {} |
| try { |
| renderBundleEncoder40.setPipeline(pipeline24); |
| } catch {} |
| try { |
| commandEncoder103.copyBufferToTexture({ |
| /* bytesInLastRow: 744 widthInBlocks: 93 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 520 */ |
| offset: 520, |
| bytesPerRow: 4864, |
| buffer: buffer77, |
| }, { |
| texture: texture135, |
| mipLevel: 0, |
| origin: {x: 146, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 93, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer115, 8, new DataView(new ArrayBuffer(86344)), 1520, 0); |
| } catch {} |
| document.body.append(canvas0); |
| await gc(); |
| let bindGroup88 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 1, resource: textureView6}, |
| {binding: 103, resource: externalTexture3}, |
| {binding: 9, resource: textureView68}, |
| {binding: 13, resource: textureView108}, |
| {binding: 30, resource: {buffer: buffer91, size: 20}}, |
| ], |
| }); |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| let texture249 = device0.createTexture({ |
| size: [4, 712, 1], |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup15, new Uint32Array(3202), 415, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 0, 0, 35_558_182); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer73, 24); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(0, buffer2, 0, 23); |
| } catch {} |
| try { |
| bindGroup60.label = ''; |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 1, resource: textureView6}, |
| {binding: 13, resource: textureView51}, |
| {binding: 30, resource: {buffer: buffer91, size: 20}}, |
| {binding: 103, resource: externalTexture16}, |
| {binding: 9, resource: textureView68}, |
| ], |
| }); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 1283}); |
| let textureView210 = texture179.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup37, new Uint32Array(4489), 1_171, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 0, 0, 448_397_125); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer73, 'uint32', 20, 23); |
| } catch {} |
| try { |
| buffer108.unmap(); |
| } catch {} |
| try { |
| commandEncoder176.resolveQuerySet(querySet4, 135, 3, buffer1, 0); |
| } catch {} |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let texture250 = device0.createTexture({size: [1697], dimension: '1d', format: 'rgba16float', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder54.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 0, 0, 853_171_354, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer8, 552); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer108, 8); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer64, 'uint16', 0, 25); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline11); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 356, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData13, |
| origin: { x: 38, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 0, y: 39, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer131 = device1.createBuffer({ |
| size: 44, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder188 = device1.createCommandEncoder(); |
| let texture251 = device1.createTexture({ |
| size: {width: 320, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView211 = texture97.createView({aspect: 'all', baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device1, computePassEncoder42); computePassEncoder42.dispatchWorkgroupsIndirect(buffer51, 64); }; |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(4, buffer31, 0); |
| } catch {} |
| let buffer132 = device1.createBuffer({ |
| label: '\u{1f8ab}\u313a\u0585\uaefe\u{1fc7d}\u78a7\ufcde\u0fb4\u{1fcb6}', |
| size: 4, |
| usage: GPUBufferUsage.INDEX, |
| }); |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| computePassEncoder54.setBindGroup(3, bindGroup84, new Uint32Array(430), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexed(0, 0, 0, 447_753_555); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(0, buffer89); |
| } catch {} |
| try { |
| renderBundleEncoder32.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(0, buffer112, 0, 35); |
| } catch {} |
| try { |
| commandEncoder181.copyTextureToTexture({ |
| texture: texture126, |
| mipLevel: 0, |
| origin: {x: 436, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture152, |
| mipLevel: 1, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 135, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder189 = device1.createCommandEncoder({}); |
| let texture252 = device1.createTexture({ |
| size: {width: 51}, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder42.end(); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup8); |
| } catch {} |
| let commandEncoder190 = device1.createCommandEncoder({}); |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer50, 0, 20); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(3, bindGroup58, new Uint32Array(1929), 30, 0); |
| } catch {} |
| try { |
| device1.pushErrorScope('validation'); |
| } catch {} |
| let imageBitmap4 = await createImageBitmap(videoFrame6); |
| let autogeneratedBindGroupLayout12 = pipeline14.getBindGroupLayout(0); |
| let buffer133 = device0.createBuffer({size: 352, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let texture253 = device0.createTexture({size: {width: 2}, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer8, 1_556); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer7, 52); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup24); |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let textureView212 = texture219.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer49, 44); }; |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer99, 56); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer73, 'uint32', 12, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 4, new Uint32Array(1809).map((_, i) => i * 10), 32, 0); |
| } catch {} |
| let texture254 = device0.createTexture({ |
| size: {width: 2, height: 356, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder57 = commandEncoder29.beginComputePass(); |
| try { |
| computePassEncoder57.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup6, new Uint32Array(1303), 345, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 104, 0, 676_558_939); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer73, 'uint16', 0, 8); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(6, buffer89, 0); |
| } catch {} |
| let videoFrame30 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt470bg', transfer: 'iec61966-2-1'} }); |
| let autogeneratedBindGroupLayout13 = pipeline13.getBindGroupLayout(0); |
| let commandEncoder193 = device1.createCommandEncoder({}); |
| let textureView213 = texture248.createView({}); |
| let computePassEncoder58 = commandEncoder174.beginComputePass(); |
| try { |
| computePassEncoder58.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer81, 'uint16', 38, 4); |
| } catch {} |
| let commandBuffer16 = commandEncoder35.finish(); |
| let texture255 = device0.createTexture({ |
| size: [1], |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView214 = texture3.createView({dimension: '2d', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer99, 48); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndirect(buffer128, 8); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(461).fill(53), /* required buffer size: 461 */ |
| {offset: 461, rowsPerImage: 84}, {width: 150, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageBitmap5 = await createImageBitmap(canvas0); |
| let texture256 = device0.createTexture({ |
| label: '\u19b1\u{1fde2}\u0871\u051b\u{1f91c}\u0867', |
| size: {width: 16, height: 16, depthOrArrayLayers: 27}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer0, 8); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 1, resource: {buffer: buffer91, size: 48}}], |
| }); |
| let buffer134 = device0.createBuffer({size: 268, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let textureView215 = texture254.createView({label: '\u{1fb2e}\u3357\u19f8\u{1f872}', arrayLayerCount: 1}); |
| let texture257 = device0.createTexture({ |
| size: {width: 2, height: 356, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup74, new Uint32Array(2579), 330, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(1, buffer89, 0, 13); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer73, 68, new DataView(new ArrayBuffer(8964)), 179, 0); |
| } catch {} |
| let externalTexture26 = device1.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup58); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer101, 'uint16', 0, 0); |
| } catch {} |
| let pipeline30 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{format: 'rgba16float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule6, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 92, |
| attributes: [ |
| {format: 'unorm16x4', offset: 4, shaderLocation: 14}, |
| {format: 'sint8x2', offset: 8, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 78, shaderLocation: 5}, |
| {format: 'unorm10-10-10-2', offset: 24, shaderLocation: 13}, |
| {format: 'uint8x2', offset: 16, shaderLocation: 6}, |
| {format: 'unorm8x2', offset: 6, shaderLocation: 11}, |
| {format: 'sint8x2', offset: 8, shaderLocation: 7}, |
| {format: 'uint32x4', offset: 12, shaderLocation: 0}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 1}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 15}, |
| {format: 'snorm8x2', offset: 18, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 608, |
| attributes: [ |
| {format: 'sint16x2', offset: 8, shaderLocation: 3}, |
| {format: 'uint16x2', offset: 260, shaderLocation: 10}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list'}, |
| }); |
| document.body.prepend(img2); |
| let buffer135 = device1.createBuffer({size: 128, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let commandEncoder195 = device1.createCommandEncoder({}); |
| try { |
| renderPassEncoder24.setPipeline(pipeline16); |
| } catch {} |
| let buffer136 = device0.createBuffer({size: 15604, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture258 = device0.createTexture({ |
| size: {width: 4, height: 712, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer128, 28); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndirect(buffer0, 8); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup60, new Uint32Array(31), 1, 0); |
| } catch {} |
| let pipeline31 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule8, |
| constants: {override16: 1, override17: 1}, |
| targets: [{format: 'rgba16float', writeMask: 0}], |
| }, |
| vertex: { |
| module: shaderModule12, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 20, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 5}, |
| {format: 'unorm8x2', offset: 4, shaderLocation: 15}, |
| {format: 'float32x3', offset: 0, shaderLocation: 4}, |
| {format: 'float32x3', offset: 0, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 4, shaderLocation: 13}, |
| {format: 'float32', offset: 0, shaderLocation: 3}, |
| {format: 'unorm8x2', offset: 4, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| document.body.prepend(canvas2); |
| let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte240m', transfer: 'linear'} }); |
| let textureView216 = texture255.createView({baseMipLevel: 0}); |
| let computePassEncoder59 = commandEncoder3.beginComputePass(); |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer108, 8); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.draw(1, 59, 0, 181_225_572); |
| } catch {} |
| try { |
| buffer83.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 316, new Uint16Array(1674).map((_, i) => i + 6)); |
| } catch {} |
| try { |
| externalTexture17.label = '\u7838\u0c67\u{1f750}\u0968\u7915\ub7e2'; |
| } catch {} |
| let commandEncoder196 = device1.createCommandEncoder({}); |
| let texture259 = device1.createTexture({ |
| size: [1280], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let externalTexture27 = device1.importExternalTexture({source: videoFrame30}); |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| try { |
| device1.queue.submit([]); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 20, new Float32Array(22102).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.077)), 1374, 4); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let imageBitmap6 = await createImageBitmap(videoFrame11); |
| let commandEncoder197 = device0.createCommandEncoder(); |
| let textureView217 = texture254.createView({mipLevelCount: 1}); |
| let texture260 = gpuCanvasContext2.getCurrentTexture(); |
| let renderBundleEncoder47 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth32float', stencilReadOnly: true}); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMinClamp: 12.96, |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup59, []); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer47, 12); |
| } catch {} |
| try { |
| renderBundleEncoder27.draw(1, 183, 0, 91_675_202); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(6, buffer2, 0, 17); |
| } catch {} |
| try { |
| commandEncoder187.copyBufferToBuffer(buffer64, 0, buffer86, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder34.insertDebugMarker('\u872d'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer129, 44, new Uint32Array(9075).map((_, i) => i * 9), 1429, 4); |
| } catch {} |
| try { |
| externalTexture9.label = ''; |
| } catch {} |
| let textureView218 = texture256.createView({label: '\ua8cc\u066c\u1571\u5c47\uff81\u{1fba7}\u{1f987}\u0d15', dimension: '2d'}); |
| let textureView219 = texture181.createView({dimension: '2d', format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 0}); |
| let sampler26 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 38.19, |
| compare: 'less-equal', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline18); |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder26.draw(0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.drawIndirect(buffer49, 44); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer72, 4, new BigInt64Array(8426).map((_, i) => BigInt(i - 0)), 725, 0); |
| } catch {} |
| let pipeline32 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout0, |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule7, |
| targets: [{ |
| format: 'rgba16float', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex3', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 28, |
| attributes: [ |
| {format: 'float32', offset: 4, shaderLocation: 9}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 10}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 3}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 8}, |
| {format: 'float32', offset: 0, shaderLocation: 12}, |
| {format: 'float32x3', offset: 4, shaderLocation: 0}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 7}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 1}, |
| {format: 'float32x4', offset: 0, shaderLocation: 6}, |
| {format: 'sint32', offset: 0, shaderLocation: 4}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 4, shaderLocation: 5}, |
| {format: 'unorm16x2', offset: 16, shaderLocation: 14}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 11}, |
| {format: 'sint32x2', offset: 4, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let bindGroup91 = device1.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 0, resource: textureView19}]}); |
| let texture261 = device1.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let externalTexture28 = device1.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup79, new Uint32Array(4271), 139, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup49, []); |
| } catch {} |
| try { |
| commandEncoder121.copyTextureToTexture({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 151}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 128, height: 128, depthOrArrayLayers: 12} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 16, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture209, |
| mipLevel: 1, |
| origin: {x: 30, y: 19, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData18 = new ImageData(24, 40); |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let texture262 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture29 = device0.importExternalTexture({source: videoFrame31}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer134, 184); }; |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndexed(1, 0, 0, 352_135_543); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer47, 'uint32', 0, 22); |
| } catch {} |
| try { |
| commandEncoder117.copyTextureToBuffer({ |
| texture: texture175, |
| mipLevel: 0, |
| origin: {x: 0, y: 44, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 160 */ |
| offset: 160, |
| bytesPerRow: 6656, |
| buffer: buffer79, |
| }, {width: 2, height: 291, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder192.pushDebugGroup('\u0728'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| let pipeline33 = await device0.createRenderPipelineAsync({ |
| label: '\u2ac3\uf705\u067a\ud1e6\u0508\u0e08\u5b83\u09ac', |
| layout: 'auto', |
| multisample: {mask: 0x1cc24a9e}, |
| fragment: { |
| module: shaderModule13, |
| constants: {8_983: 1}, |
| targets: [{format: 'rg8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule13, |
| constants: {8_983: 1}, |
| buffers: [ |
| { |
| arrayStride: 12, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x3', offset: 0, shaderLocation: 10}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 11}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 9}, |
| {format: 'sint32x3', offset: 0, shaderLocation: 0}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 4}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 15}, |
| {format: 'float32x3', offset: 0, shaderLocation: 1}, |
| {format: 'float16x4', offset: 0, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 80, |
| attributes: [ |
| {format: 'unorm16x4', offset: 4, shaderLocation: 13}, |
| {format: 'float16x4', offset: 12, shaderLocation: 8}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'float32', offset: 12, shaderLocation: 2}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 5}, |
| ], |
| }, |
| {arrayStride: 24, attributes: [{format: 'unorm10-10-10-2', offset: 0, shaderLocation: 6}]}, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let videoFrame32 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} }); |
| let bindGroup92 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout29, |
| entries: [{binding: 2, resource: {buffer: buffer110}}, {binding: 0, resource: {buffer: buffer127, size: 28}}], |
| }); |
| let buffer137 = device1.createBuffer({size: 56, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let commandEncoder199 = device1.createCommandEncoder({}); |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup82, new Uint32Array(246), 7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture213, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(246).fill(248), /* required buffer size: 246 */ |
| {offset: 246}, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView220 = texture71.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup52, new Uint32Array(2015), 96, 0); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(0, bindGroup22, new Uint32Array(8476), 249, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(1, buffer32, 28, 0); |
| } catch {} |
| try { |
| device1.addEventListener('uncapturederror', e => { console.log('device1.uncapturederror'); console.log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| device1.lost.then(r => { console.log('device1 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let texture263 = device1.createTexture({ |
| size: {width: 1280, height: 1, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder60 = commandEncoder173.beginComputePass(); |
| let sampler27 = device1.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 69.74, |
| }); |
| try { |
| computePassEncoder60.setPipeline(pipeline0); |
| } catch {} |
| let textureView221 = texture254.createView({}); |
| let textureView222 = texture147.createView({}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexedIndirect(buffer8, 17_976); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(7, buffer112, 40, 41); |
| } catch {} |
| try { |
| adapter1.label = '\u843b\u0adc\u7f99\u00b8\ua764\u4446\ua36a\u0e6c'; |
| } catch {} |
| let commandEncoder200 = device1.createCommandEncoder({}); |
| let texture264 = device1.createTexture({ |
| size: [39], |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup53); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer131, 'uint16', 8, 1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline24); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 640, height: 1, depthOrArrayLayers: 438} |
| */ |
| { |
| source: videoFrame14, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture236, |
| mipLevel: 0, |
| origin: {x: 56, y: 0, z: 34}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup69, new Uint32Array(432), 152, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline12); |
| } catch {} |
| let textureView223 = texture262.createView({}); |
| let texture265 = device0.createTexture({ |
| size: [8, 1424, 56], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView224 = texture5.createView({dimension: '2d', baseArrayLayer: 3}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer0, 16); }; |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 0, 0, 309_742_869); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer8, 5_044); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer87); |
| } catch {} |
| try { |
| renderBundleEncoder47.setBindGroup(0, bindGroup16, new Uint32Array(2377), 61, 0); |
| } catch {} |
| try { |
| commandEncoder192.popDebugGroup(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let autogeneratedBindGroupLayout14 = pipeline1.getBindGroupLayout(1); |
| let commandBuffer17 = commandEncoder38.finish(); |
| let textureView225 = texture245.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderPassEncoder1.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup8, new Uint32Array(3124), 118, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder188.copyTextureToBuffer({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1408 */ |
| offset: 1408, |
| bytesPerRow: 6144, |
| rowsPerImage: 218, |
| buffer: buffer110, |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder201 = device1.createCommandEncoder({}); |
| let imageData19 = new ImageData(244, 12); |
| let pipelineLayout7 = device1.createPipelineLayout({ |
| bindGroupLayouts: [autogeneratedBindGroupLayout6, autogeneratedBindGroupLayout2, veryExplicitBindGroupLayout35, autogeneratedBindGroupLayout1], |
| }); |
| try { |
| computePassEncoder60.setBindGroup(0, bindGroup8, new Uint32Array(69), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer132, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(0, buffer88, 12, 12); |
| } catch {} |
| document.body.append(img2); |
| let commandEncoder202 = device1.createCommandEncoder(); |
| let renderBundleEncoder48 = device1.createRenderBundleEncoder({colorFormats: ['rgba16float'], depthReadOnly: true}); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup87, new Uint32Array(1901), 254, 0); |
| } catch {} |
| try { |
| commandEncoder165.copyBufferToBuffer(buffer123, 0, buffer75, 12, 0); |
| } catch {} |
| let pipeline34 = device1.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule9, |
| targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| constants: {override19: 1, 7_569: 1}, |
| buffers: [ |
| { |
| arrayStride: 8, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm8x2', offset: 2, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 10}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 13}, |
| {format: 'float16x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 5}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 1}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 7}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 15}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 0}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 4}, |
| {format: 'sint32', offset: 0, shaderLocation: 14}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 0, shaderLocation: 2}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| {arrayStride: 0, attributes: [{format: 'uint16x4', offset: 360, shaderLocation: 6}]}, |
| ], |
| }, |
| }); |
| try { |
| externalTexture27.label = '\u3d93\u07fc\u2c21\u{1f860}\uf3f7\uf89b\ud126\u{1f9e9}\u{1f8bc}'; |
| } catch {} |
| let commandEncoder203 = device1.createCommandEncoder({}); |
| let texture266 = device1.createTexture({ |
| size: {width: 39, height: 41, depthOrArrayLayers: 31}, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder61 = commandEncoder33.beginComputePass(); |
| let renderPassEncoder28 = commandEncoder170.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView102, |
| clearValue: { r: 991.7, g: 343.9, b: 191.4, a: -274.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup47); |
| } catch {} |
| try { |
| renderBundleEncoder40.setIndexBuffer(buffer101, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setPipeline(pipeline6); |
| } catch {} |
| try { |
| device1.lost.then(({reason, message}) => { console.log('device1 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture172, |
| mipLevel: 0, |
| origin: {x: 108, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(38).fill(152), /* required buffer size: 38 */ |
| {offset: 38}, {width: 115, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'jedecP22Phosphors', transfer: 'smpte240m'} }); |
| try { |
| globalThis.someLabel = device1.queue.label; |
| } catch {} |
| let buffer138 = device1.createBuffer({size: 72, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let texture267 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture268 = device1.createTexture({ |
| size: [156, 164, 169], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder39.end(); |
| } catch {} |
| try { |
| computePassEncoder61.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder81.copyBufferToBuffer(buffer123, 0, buffer110, 1064, 0); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(31); }; |
| } catch {} |
| let veryExplicitBindGroupLayout36 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }}, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| {binding: 52, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer139 = device0.createBuffer({size: 464, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder204 = device0.createCommandEncoder({}); |
| let renderBundle6 = renderBundleEncoder27.finish(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer99, 44); }; |
| } catch {} |
| try { |
| renderPassEncoder9.draw(234, 0, 305_063_713); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer49, 52); |
| } catch {} |
| try { |
| renderBundleEncoder31.setBindGroup(0, bindGroup45, new Uint32Array(4680), 290, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer134, 68, new DataView(new ArrayBuffer(6474)), 1236, 124); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer140 = device1.createBuffer({size: 171, usage: GPUBufferUsage.INDEX}); |
| let commandBuffer18 = commandEncoder34.finish(); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup58, new Uint32Array(2510), 81, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup79); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline28); |
| } catch {} |
| try { |
| commandEncoder81.resolveQuerySet(querySet2, 26, 8, buffer103, 0); |
| } catch {} |
| document.body.prepend(img2); |
| let bindGroup93 = device0.createBindGroup({ |
| label: '', |
| layout: veryExplicitBindGroupLayout11, |
| entries: [{binding: 1, resource: {buffer: buffer71}}], |
| }); |
| try { |
| renderPassEncoder4.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer47, 0); |
| } catch {} |
| let textureView226 = texture200.createView({arrayLayerCount: 1}); |
| let sampler28 = device1.createSampler({label: '\u0398', addressModeW: 'repeat', minFilter: 'linear', lodMaxClamp: 99.86}); |
| try { |
| renderBundleEncoder6.setVertexBuffer(4, buffer131); |
| } catch {} |
| let promise15 = device1.queue.onSubmittedWorkDone(); |
| await gc(); |
| let commandEncoder205 = device1.createCommandEncoder(); |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let buffer141 = device0.createBuffer({size: 188, usage: GPUBufferUsage.COPY_SRC}); |
| let texture269 = device0.createTexture({ |
| size: {width: 1697, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView227 = texture128.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup65, new Uint32Array(3319), 449, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer112, 'uint16', 0, 3); |
| } catch {} |
| let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpte240m', transfer: 'bt2020_12bit'} }); |
| let recycledExplicitBindGroupLayout3 = pipeline25.getBindGroupLayout(0); |
| let textureView228 = texture253.createView({aspect: 'all'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer47, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup6, new Uint32Array(40), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline29); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 80} |
| */ |
| { |
| source: videoFrame25, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 5, y: 4, z: 16}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter1.label = '\u6d78\uf303\u{1ffd6}\uc782\u485c\u0b0d\u03e4\u0b03\u0177'; |
| } catch {} |
| let commandEncoder206 = device0.createCommandEncoder({}); |
| let commandBuffer19 = commandEncoder2.finish({}); |
| let texture270 = device0.createTexture({ |
| size: {width: 1, height: 178, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup44, new Uint32Array(1019), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndexed(2, 0, 0, 1_150_283_779); |
| } catch {} |
| try { |
| renderBundleEncoder46.setIndexBuffer(buffer64, 'uint16', 0, 0); |
| } catch {} |
| let commandEncoder207 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder37.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder3.draw(2, 188, 0, 2_570_443_794); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(1, 0, 0, 268_832_930, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndirect(buffer99, 28); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer89, 0, 19); |
| } catch {} |
| try { |
| renderBundleEncoder47.setVertexBuffer(5, buffer112, 24); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer134, 80, new DataView(new ArrayBuffer(7848)), 114, 4); |
| } catch {} |
| let pipeline35 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule11, entryPoint: 'compute11'}}); |
| let commandEncoder208 = device1.createCommandEncoder({}); |
| let texture271 = device1.createTexture({ |
| label: '\u693b\u{1fc5c}\u0d4f\u38b4\u3772', |
| size: {width: 640, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer32, 'uint16', 8, 4); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder130.copyBufferToTexture({ |
| /* bytesInLastRow: 232 widthInBlocks: 29 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 744 */ |
| offset: 744, |
| buffer: buffer77, |
| }, { |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 29, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer12, 0, new Uint32Array(9577).map((_, i) => i * 8), 2511, 0); |
| } catch {} |
| let commandEncoder209 = device1.createCommandEncoder(); |
| let texture272 = device1.createTexture({ |
| size: {width: 640, height: 1, depthOrArrayLayers: 397}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder41.setBindGroup(1, bindGroup21, new Uint32Array(5611), 1_438, 1); |
| } catch {} |
| try { |
| commandEncoder127.copyBufferToBuffer(buffer21, 4, buffer115, 4, 0); |
| } catch {} |
| try { |
| commandEncoder179.resolveQuerySet(querySet2, 35, 2, buffer125, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout37 = device1.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 27, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 98, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup94 = device1.createBindGroup({ |
| layout: veryExplicitBindGroupLayout25, |
| entries: [ |
| {binding: 174, resource: sampler3}, |
| {binding: 236, resource: textureView92}, |
| {binding: 3, resource: {buffer: buffer117}}, |
| {binding: 1, resource: textureView17}, |
| {binding: 379, resource: {buffer: buffer110, offset: 0}}, |
| {binding: 0, resource: textureView36}, |
| {binding: 6, resource: textureView169}, |
| {binding: 68, resource: textureView45}, |
| ], |
| }); |
| let commandEncoder210 = device1.createCommandEncoder({}); |
| let texture273 = device1.createTexture({ |
| size: {width: 19, height: 20, depthOrArrayLayers: 20}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder49 = device1.createRenderBundleEncoder({colorFormats: ['rgba16uint', 'rg32float'], sampleCount: 1}); |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer140, 'uint32', 0, 6); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup33, new Uint32Array(449), 6, 1); |
| } catch {} |
| let bindGroup95 = device1.createBindGroup({layout: autogeneratedBindGroupLayout9, entries: [{binding: 98, resource: textureView80}]}); |
| let texture274 = device1.createTexture({ |
| size: {width: 102, height: 1, depthOrArrayLayers: 355}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer61); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let texture275 = device1.createTexture({ |
| size: [19, 20, 295], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler29 = device1.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 87.94, maxAnisotropy: 20}); |
| try { |
| renderPassEncoder24.setScissorRect(16, 86, 9, 7); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder107.copyTextureToTexture({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 68, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 54}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder211 = device1.createCommandEncoder({label: '\u{1fef8}\u3d9e\u0735\u{1fda9}\u0cc7\u7a28\u55c5\u0cdc'}); |
| let textureView229 = texture227.createView({mipLevelCount: 1}); |
| let textureView230 = texture201.createView({dimension: '1d'}); |
| let computePassEncoder62 = commandEncoder143.beginComputePass(); |
| try { |
| computePassEncoder56.setBindGroup(2, bindGroup69); |
| } catch {} |
| try { |
| computePassEncoder34.setBindGroup(1, bindGroup0, new Uint32Array(131), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer107, 'uint16', 16, 67); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer81, 'uint32', 0, 16); |
| } catch {} |
| try { |
| commandEncoder179.copyBufferToTexture({ |
| /* bytesInLastRow: 280 widthInBlocks: 35 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 456 */ |
| offset: 456, |
| bytesPerRow: 15616, |
| rowsPerImage: 233, |
| buffer: buffer77, |
| }, { |
| texture: texture172, |
| mipLevel: 0, |
| origin: {x: 93, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 35, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder158.copyTextureToBuffer({ |
| texture: texture149, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 40 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2864 */ |
| offset: 2864, |
| buffer: buffer30, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device1.queue.copyExternalImageToTexture(/* |
| {width: 19, height: 20, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame28, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture233, |
| mipLevel: 0, |
| origin: {x: 5, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| veryExplicitBindGroupLayout24.label = '\u{1f964}'; |
| } catch {} |
| let bindGroup96 = device1.createBindGroup({ |
| layout: autogeneratedBindGroupLayout5, |
| entries: [{binding: 1, resource: {buffer: buffer50, size: 8}}], |
| }); |
| let textureView231 = texture274.createView({}); |
| let textureView232 = texture241.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup62, []); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer131, 'uint32', 4, 6); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(0, buffer88, 8, 24); |
| } catch {} |
| try { |
| commandEncoder152.copyBufferToBuffer(buffer77, 128, buffer31, 12, 8); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(26).fill(181), /* required buffer size: 26 */ |
| {offset: 26}, {width: 19, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline36 = device1.createComputePipeline({layout: 'auto', compute: {module: shaderModule6, constants: {}}}); |
| let textureView233 = texture86.createView({dimension: '2d', baseArrayLayer: 3}); |
| try { |
| renderPassEncoder20.setBlendConstant({ r: -248.0, g: 698.2, b: 954.5, a: -950.0, }); |
| } catch {} |
| try { |
| renderPassEncoder3.drawIndexedIndirect(buffer8, 748); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer48, 'uint16', 2, 4); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(2, buffer112, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 178, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 1, y: 11 }, |
| flipY: true, |
| }, { |
| texture: texture94, |
| mipLevel: 0, |
| origin: {x: 0, y: 29, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt709', transfer: 'smpteSt4281'} }); |
| try { |
| externalTexture19.label = '\u0b30\u83aa\u{1fa1a}\u83ba\u{1fcab}\u0fd6\u{1fa08}\u{1f899}\ue835'; |
| } catch {} |
| let commandEncoder212 = device0.createCommandEncoder({}); |
| let texture276 = device0.createTexture({size: [2, 356, 1], format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder5.end(); |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline35); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup50, new Uint32Array(3011), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer128, 4); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndirect(buffer73, 4); |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1704 */ |
| offset: 1704, |
| buffer: buffer136, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder119.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 283, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2912 */ |
| offset: 2912, |
| buffer: buffer46, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder36.pushDebugGroup('\u0457'); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture6.label; |
| } catch {} |
| let texture277 = device0.createTexture({size: [424, 1, 38], format: 'depth32float', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(4); }; |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndexedIndirect(buffer47, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer108, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(0, bindGroup67, new Uint32Array(5786), 1_558, 0); |
| } catch {} |
| try { |
| renderBundleEncoder33.setIndexBuffer(buffer10, 'uint16', 86, 88); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let buffer142 = device1.createBuffer({size: 448, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder213 = device1.createCommandEncoder({}); |
| try { |
| renderBundleEncoder48.setVertexBuffer(4, buffer85); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 1, resource: textureView6}, |
| {binding: 103, resource: externalTexture3}, |
| {binding: 13, resource: textureView108}, |
| {binding: 9, resource: textureView68}, |
| {binding: 30, resource: {buffer: buffer114}}, |
| ], |
| }); |
| let commandEncoder214 = device0.createCommandEncoder(); |
| let textureView234 = texture166.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderPassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(54, 0, 584_595_089); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndexed(2, 0, 0, 47_102_994); |
| } catch {} |
| try { |
| renderBundleEncoder33.setBindGroup(0, bindGroup93); |
| } catch {} |
| let commandEncoder215 = device0.createCommandEncoder(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer104, 8, new DataView(new Uint8Array(620).map((_, i) => i).buffer), 115, 28); |
| } catch {} |
| let commandEncoder216 = device0.createCommandEncoder({}); |
| let textureView235 = texture173.createView({baseArrayLayer: 0}); |
| let textureView236 = texture87.createView({}); |
| let renderBundleEncoder50 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth32float'}); |
| try { |
| computePassEncoder51.setBindGroup(2, bindGroup20, new Uint32Array(1641), 606, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.drawIndexed(1, 0, 0, 1_034_742_047); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline25); |
| } catch {} |
| let bindGroup98 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 1, resource: {buffer: buffer49, size: 60}}], |
| }); |
| let texture278 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer128, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer100, 'uint32', 16, 17); |
| } catch {} |
| try { |
| renderBundleEncoder28.setBindGroup(0, bindGroup83); |
| } catch {} |
| try { |
| renderBundleEncoder46.setIndexBuffer(buffer92, 'uint16', 32, 21); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 20, new Float32Array(19081).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.607)), 1504, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 16, depthOrArrayLayers: 80} |
| */ |
| { |
| source: videoFrame18, |
| origin: { x: 2, y: 38 }, |
| flipY: false, |
| }, { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 13}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| await gc(); |
| let commandEncoder217 = device0.createCommandEncoder(); |
| let computePassEncoder63 = commandEncoder101.beginComputePass(); |
| try { |
| renderPassEncoder26.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 0, 0, 414_983_600); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer118, 324, new Uint32Array(15624).map((_, i) => i * 3), 2496, 8); |
| } catch {} |
| let textureView237 = texture174.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let computePassEncoder64 = commandEncoder192.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer7, 8); }; |
| } catch {} |
| try { |
| computePassEncoder64.setPipeline(pipeline35); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexed(0, 0, 0, 369_438_159, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer79, 4, 1); |
| } catch {} |
| try { |
| commandEncoder36.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 56, new Float32Array(6134).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.315)), 913, 12); |
| } catch {} |
| let pipeline37 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute1', constants: {}}}); |
| let renderBundleEncoder51 = device0.createRenderBundleEncoder({colorFormats: ['rg8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder26.drawIndexed(2, 0, 0, 711_572_442); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer79, 104); |
| } catch {} |
| let pipeline38 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, constants: {override17: 1, override16: 1}}}); |
| let commandEncoder218 = device0.createCommandEncoder({}); |
| let externalTexture30 = device0.importExternalTexture({source: videoFrame19}); |
| try { |
| computePassEncoder59.setBindGroup(3, bindGroup9, []); |
| } catch {} |
| try { |
| computePassEncoder63.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndexed(2, 0, 0, -1_906_354_931); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer129, 'uint32', 92, 104); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer100, 'uint32', 8, 2); |
| } catch {} |
| try { |
| renderBundleEncoder47.setVertexBuffer(0, buffer79, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer19]); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise16; |
| } catch {} |
| let texture279 = device0.createTexture({ |
| size: [2, 356, 1], |
| mipLevelCount: 2, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup20, new Uint32Array(2619), 133, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.draw(0, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer134, 16); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder219 = device1.createCommandEncoder({}); |
| try { |
| computePassEncoder36.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup96); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup22, new Uint32Array(1626), 507, 0); |
| } catch {} |
| try { |
| buffer23.unmap(); |
| } catch {} |
| try { |
| commandEncoder195.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 976 */ |
| offset: 976, |
| rowsPerImage: 1273, |
| buffer: buffer77, |
| }, { |
| texture: texture58, |
| mipLevel: 1, |
| origin: {x: 6, y: 0, z: 3}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroup99 = device1.createBindGroup({ |
| layout: autogeneratedBindGroupLayout11, |
| entries: [{binding: 2, resource: {buffer: buffer127, size: 48}}], |
| }); |
| let buffer143 = device1.createBuffer({size: 8, usage: GPUBufferUsage.COPY_SRC}); |
| let commandEncoder220 = device1.createCommandEncoder({}); |
| let textureView238 = texture71.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder56.setBindGroup(2, bindGroup52, new Uint32Array(302), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline13); |
| } catch {} |
| let commandEncoder221 = device0.createCommandEncoder({label: '\ud029\u0331\u91c4'}); |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup90, []); |
| } catch {} |
| try { |
| renderPassEncoder6.end(); |
| } catch {} |
| try { |
| renderPassEncoder17.drawIndexed(1, 46, 0, -2_011_886_048, 115_026_085); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer134, 88); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer89, 44, 2); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\uddd2'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 92, new DataView(new Uint8Array(2784).map((_, i) => i).buffer), 501, 12); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| videoFrame29.close(); |
| videoFrame30.close(); |
| videoFrame31.close(); |
| videoFrame32.close(); |
| videoFrame33.close(); |
| videoFrame34.close(); |
| videoFrame35.close(); |
| } |
| async function window1() { |
| let promise0 = navigator.gpu.requestAdapter({}); |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let adapter1 = await navigator.gpu.requestAdapter(); |
| let promise1 = adapter1.requestDevice({ |
| requiredFeatures: ['shader-f16'], |
| requiredLimits: {maxStorageBufferBindingSize: 175161326, maxUniformBufferBindingSize: 24641468}, |
| }); |
| let device0 = await promise1; |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'iec6196624'} }); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 59, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 61, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 109, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 153, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 308, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 312, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 524, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let texture0 = device0.createTexture({ |
| size: [256, 256, 203], |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView0 = texture0.createView({}); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let texture1 = device0.createTexture({ |
| size: [256, 256, 19], |
| mipLevelCount: 4, |
| format: 'rg16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture2 = device0.createTexture({ |
| size: [690, 1, 37], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 28, y: 22, z: 22}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer0 = device0.createBuffer({size: 620, usage: GPUBufferUsage.INDIRECT}); |
| let texture3 = device0.createTexture({ |
| size: {width: 345}, |
| dimension: '1d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView1 = texture3.createView({}); |
| try { |
| globalThis.someLabel = textureView0.label; |
| } catch {} |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder1 = device0.createCommandEncoder(); |
| let texture4 = device0.createTexture({ |
| size: [828, 1, 1], |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let textureView2 = texture1.createView({dimension: 'cube-array', mipLevelCount: 2, baseArrayLayer: 1, arrayLayerCount: 6}); |
| let texture5 = device0.createTexture({ |
| size: [414, 1, 1], |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView3 = texture4.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true}); |
| try { |
| veryExplicitBindGroupLayout2.label = '\u2a2a\ud700\uf127\u84a8'; |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| @group(1) @binding(93) var st1: texture_storage_1d<rgba32sint, read>; |
| |
| struct T1 { |
| @size(16) f0: atomic<i32>, |
| } |
| |
| struct T5 { |
| f0: array<array<vec2i, 1>>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentInput3 { |
| @location(5) location_5: vec4h, |
| } |
| |
| struct T4 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T3 { |
| @align(8) f0: array<array<f16, 14>>, |
| } |
| |
| @id(58764) override override0: u32 = (705493666 % 103) + 1; |
| |
| struct T6 { |
| @align(8) f0: array<atomic<i32>>, |
| } |
| |
| struct T0 { |
| f0: array<u32, 32>, |
| @align(8) @size(128) f1: atomic<i32>, |
| @size(384) f2: array<array<atomic<i32>, 4>, 1>, |
| f3: array<array<atomic<i32>, 1>>, |
| } |
| |
| struct ComputeInput0 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| struct FragmentInput0 { |
| @location(2) @interpolate(linear, centroid) location_2: vec2f, |
| @location(14) @interpolate(perspective, centroid) location_14: f16, |
| } |
| |
| struct VertexInput1 { |
| @location(9) location_9: f32, |
| } |
| |
| var<private> vp1: array<u32, 40> = array<u32, 40>(u32(1423838915), u32(326491431), u32(2119806305), u32(1662692236), u32(1037945241), u32(1928406291), u32(1057850745), u32(2902840888), u32(661395436), u32(55413696), u32(256827667), u32(176895435), u32(8047532), u32(1101801793), u32(1273227544), u32(133718569), u32(571320255), u32(125118434), u32(66848407), u32(354584102), u32(175610453), u32(1314837497), u32(113661415), u32(867609415), u32(3599471605), u32(923911212), u32(366185443), u32(1172369296), u32(290971450), u32(673988678), u32(96754695), u32(899571375), u32(49881458), u32(366726435), u32(44553738), u32(46037114), u32(658980187), u32(279147503), u32(181687720), u32(147961781)); |
| |
| struct VertexInput2 { |
| @location(13) @interpolate(flat) location_13: i32, |
| } |
| |
| @id(48613) override override2: f32; |
| |
| var<private> vp0 = modf(vec2h(2040.4, 776.3)); |
| |
| var<private> vp3: vec2i = vec2i(95279000, 15828716); |
| |
| struct VertexInput0 { |
| @location(12) @interpolate(flat) location_12: vec4f, |
| @location(14) location_14: vec4f, |
| @location(5) location_5: vec4h, |
| @location(15) @interpolate(flat) location_15: vec4u, |
| @location(2) location_2: vec4h, |
| @location(10) @interpolate(flat, sample) location_10: vec2h, |
| @location(7) location_7: vec2u, |
| } |
| |
| override override3: u32 = (415515337 % 103) + 1; |
| |
| struct FragmentOutput0 { |
| @location(5) location_5: vec2i, |
| @location(0) @interpolate(flat, centroid) location_0: vec4i, |
| } |
| |
| struct FragmentInput1 { |
| @location(5) location_5: vec4h, |
| } |
| |
| @id(14197) override override1: f16; |
| |
| override override4: f32; |
| |
| var<workgroup> vw0: i32; |
| |
| struct VertexOutput0 { |
| @location(14) @interpolate(perspective, centroid) location_14: f16, |
| @invariant @builtin(position) position: vec4f, |
| @location(10) location_10: vec2u, |
| @location(5) location_5: vec4h, |
| @location(8) @interpolate(linear, centroid) location_8: vec4f, |
| @location(2) @interpolate(linear, centroid) location_2: vec2f, |
| } |
| |
| var<private> vp2: array<vec2i, 13> = array<vec2i, 13>(); |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexInput3 { |
| @location(11) location_11: f32, |
| } |
| |
| @group(0) @binding(93) var st0: texture_storage_1d<rgba32sint, read>; |
| |
| struct FragmentInput2 { |
| @location(2) @interpolate(linear, centroid) location_2: vec2f, |
| } |
| |
| struct T2 { |
| f0: array<array<T1, 1>>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: st1 */ |
| @vertex |
| fn vertex0(@location(4) location_4: u32, a1: VertexInput0, a2: VertexInput1, a3: VertexInput2, @location(8) @interpolate(flat) location_8: vec4i, @builtin(vertex_index) vertex_index: u32, a6: VertexInput3) -> VertexOutput0 { |
| var out: VertexOutput0; |
| vp2[unconst_u32(26306385)] = bitcast<vec2i>(unpack4x8unorm(unconst_u32(1501353532)).br.rr.rr.yy.gr.xx.rg.gg.xx.rg); |
| out = VertexOutput0(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2)))[0], vec4f(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).rgrg), vec2u(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).yy), floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).grrg, vec4f(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))).rrrr.rgaa.xxxy), vec2f(floor(vec2h(unconst_f16(2817.2), unconst_f16(19225.2))))); |
| var vf0: f32 = out.location_2[unconst_u32(1525366310)]; |
| let ptr0: ptr<function, vec2u> = &out.location_10; |
| out.location_10 += vec2u(bitcast<u32>(a1.location_14[unconst_u32(2694144421)])); |
| out.position = vec4f(textureLoad(st1, unconst_i32(725447499)).yzwz); |
| return out; |
| _ = st1; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment0(@location(8) @interpolate(linear) location_8: vec4f, a1: FragmentInput0, a2: FragmentInput1) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| var vf1: FragmentInput1 = a2; |
| var vf2: vec2f = a1.location_2; |
| let vf3: vec2f = atanh(vec2f(unconst_f32(0.05919e-37), unconst_f32(0.1800))); |
| return out; |
| } |
| |
| /* used global variables: st0 */ |
| @fragment |
| fn fragment1(a0: FragmentInput2, @location(10) @interpolate(flat, centroid) location_10: vec2u, a2: FragmentInput3) -> @location(200) vec4i { |
| var out: vec4i; |
| vp3 += vec2i(i32(textureDimensions(st0))); |
| vp0.whole = bitcast<vec2h>(vp2[unconst_u32(69289615)][unconst_u32(836792121)]); |
| var vf4: i32 = vp2[12][unconst_u32(1104178073)]; |
| for (var jj40=0u; jj40<15; jj40++) { vp2[jj40] = countLeadingZeros(vec3i(unconst_i32(104927857), unconst_i32(425508417), unconst_i32(261798975))).zz; } |
| vp0 = modf(bitcast<vec2h>(cos(unconst_f32(0.2199)))); |
| return out; |
| _ = st0; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(8, 2, 1) |
| fn compute0(a0: ComputeInput0) { |
| vp1[39] &= vec2u(vp2[12])[1]; |
| let vf5: f32 = override4; |
| let vf6: vec2h = sqrt(vec2h(unconst_f16(4621.2), unconst_f16(-1148.5))); |
| vp0 = modf(vp0.whole); |
| vp2[unconst_u32(90467102)] |= vec2i(bitcast<i32>(vp1[39])); |
| var vf7: vec4i = unpack4xI8(reverseBits(vec2u(unconst_u32(172866832), unconst_u32(212281484)))[1]); |
| vp2[unconst_u32(108556843)] = vec2i(refract(vec2h(unconst_f16(1813.8), unconst_f16(15123.7)), vec2h(unconst_f16(867.1), unconst_f16(12946.7)), unconst_f16(3330.7))); |
| let vf8: ptr<workgroup, i32> = &vw0; |
| var vf9: vec3f = ceil(vec3f(unconst_f32(0.04753), unconst_f32(0.1866), unconst_f32(-0.1424e30))); |
| let vf10: vec2f = fma(vec2f(unconst_f32(0.01866), unconst_f32(0.05296e-43)), vec2f(unconst_f32(-0.04896), unconst_f32(0.1797)), vec2f(unconst_f32(0.2411e-9), unconst_f32(0.09721e36))); |
| _ = override4; |
| }`, |
| }); |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| label: '\u1ae9\u7702\u7738\uec85\u{1f8ae}\u0c6d\u0adf\ua1f5', |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let buffer1 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let texture6 = device0.createTexture({ |
| size: {width: 2}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder0 = commandEncoder1.beginComputePass(); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder0.setVertexBuffer(0, undefined, 0, 468_327_760); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let texture7 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 4}, |
| mipLevelCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| let bindGroup0 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let textureView4 = texture1.createView({dimension: 'cube-array', mipLevelCount: 2, baseArrayLayer: 1, arrayLayerCount: 6}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: false}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(3850), 227, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.insertDebugMarker('\u03db'); |
| } catch {} |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup0, new Uint32Array(2686), 448, 0); |
| } catch {} |
| let buffer2 = device0.createBuffer({size: 92, usage: GPUBufferUsage.COPY_DST}); |
| let textureView5 = texture3.createView({format: 'rgba32sint', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup0); |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer3 = device0.createBuffer({size: 6108, usage: GPUBufferUsage.VERTEX}); |
| let texture8 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 448}, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView6 = texture2.createView({aspect: 'all', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 3}); |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'unspecified', transfer: 'logSqrt'} }); |
| let bindGroup2 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2, veryExplicitBindGroupLayout3]}); |
| let buffer4 = device0.createBuffer({size: 8, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let texture9 = device0.createTexture({ |
| size: {width: 4}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder1 = commandEncoder3.beginComputePass(); |
| let pipeline0 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule0, constants: {override4: 1}}}); |
| let buffer5 = device0.createBuffer({size: 104, usage: GPUBufferUsage.COPY_DST}); |
| let textureView7 = texture7.createView({arrayLayerCount: 1}); |
| let texture10 = device0.createTexture({ |
| size: [690], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView8 = texture7.createView({arrayLayerCount: 1}); |
| let computePassEncoder2 = commandEncoder2.beginComputePass(); |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 8, y: 11, z: 26}, |
| aspect: 'all', |
| }, new Uint8Array(800_328).fill(101), /* required buffer size: 800_328 */ |
| {offset: 148, bytesPerRow: 132, rowsPerImage: 243}, {width: 16, height: 230, depthOrArrayLayers: 25}); |
| } catch {} |
| let videoFrame2 = new VideoFrame(videoFrame0, {timestamp: 0}); |
| let bindGroup3 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let texture11 = device0.createTexture({ |
| size: [828, 1, 1], |
| sampleCount: 4, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture12 = device0.createTexture({ |
| size: [690, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer3, 84, 279); |
| } catch {} |
| let commandEncoder4 = device0.createCommandEncoder(); |
| let texture13 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture14 = device0.createTexture({ |
| size: [828, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeBuffer(buffer2, 12, new Float16Array(5336).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * -0.8232)), 867, 0); |
| } catch {} |
| let commandEncoder5 = device0.createCommandEncoder(); |
| let texture15 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup2); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'smpteSt4281', transfer: 'gamma28curve'} }); |
| let buffer6 = device0.createBuffer({size: 110, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 339}, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView9 = texture7.createView({baseMipLevel: 0, arrayLayerCount: 2}); |
| let textureView10 = texture16.createView({}); |
| try { |
| renderBundleEncoder1.insertDebugMarker('\u0aa0'); |
| } catch {} |
| let pipeline1 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {override4: 1}}}); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'pq'} }); |
| let textureView11 = texture9.createView({}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup2, []); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup1, new Uint32Array(319), 39, 0); |
| } catch {} |
| let pipeline2 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x1dfbed59}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 156, shaderLocation: 13}, |
| {format: 'sint32x3', offset: 292, shaderLocation: 8}, |
| {format: 'uint8x2', offset: 432, shaderLocation: 4}, |
| {format: 'unorm16x4', offset: 88, shaderLocation: 10}, |
| {format: 'float32x3', offset: 0, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 268, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 572, shaderLocation: 2}, |
| {format: 'snorm8x4', offset: 140, shaderLocation: 5}, |
| {format: 'snorm16x4', offset: 144, shaderLocation: 14}, |
| {format: 'unorm16x4', offset: 388, shaderLocation: 9}, |
| {format: 'uint16x2', offset: 72, shaderLocation: 7}, |
| {format: 'float16x4', offset: 72, shaderLocation: 11}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let textureView12 = texture15.createView({}); |
| let texture17 = device0.createTexture({ |
| size: [414, 1, 1], |
| sampleCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup1, new Uint32Array(5957), 1_481, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 0, new Uint32Array(24845).map((_, i) => i * 10), 3693, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 39, y: 109, z: 45}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer7 = device0.createBuffer({size: 124, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture18 = device0.createTexture({ |
| size: [828, 1, 1], |
| sampleCount: 4, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup3, new Uint32Array(1720), 725, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(2, bindGroup3, new Uint32Array(1102), 303, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer6, 'uint16', 32, 3); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer3, 0, 613); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let textureView13 = texture8.createView({baseMipLevel: 0}); |
| let texture19 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup4, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer0, 84); }; |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| let commandEncoder7 = device0.createCommandEncoder({label: ''}); |
| let texture20 = device0.createTexture({ |
| size: [345, 1, 60], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture21 = device0.createTexture({ |
| size: [345, 1, 1], |
| mipLevelCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder3 = commandEncoder6.beginComputePass(); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(1560), 5, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroupsIndirect(buffer1, 0); }; |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer6, 'uint32', 12, 18); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(5, buffer6, 36); |
| } catch {} |
| let texture22 = device0.createTexture({ |
| size: [4, 4, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new Float32Array(10962).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2679)), 3277, 4); |
| } catch {} |
| let textureView14 = texture1.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 3}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder0.end(); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup3, new Uint32Array(837), 42, 0); |
| } catch {} |
| let texture23 = device0.createTexture({ |
| size: [1656, 1, 30], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture24 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder0.setVertexBuffer(2, buffer6); |
| } catch {} |
| try { |
| commandEncoder5.clearBuffer(buffer2, 12); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct FragmentInput6 { |
| @location(5) location_5: vec4h, |
| } |
| |
| @group(0) @binding(153) var<storage, read_write> buffer14: array<array<array<array<f16, 1>, 13>, 32>>; |
| |
| struct ComputeInput1 { |
| @builtin(global_invocation_id) global_invocation_id: vec3u, |
| } |
| |
| struct T1 { |
| f0: array<vec2<bool>>, |
| } |
| |
| struct VertexInput4 { |
| @location(2) location_2: vec2u, |
| @location(14) @interpolate(linear) location_14: vec4h, |
| @location(0) location_0: vec4h, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexInput5 { |
| @location(7) location_7: u32, |
| @location(1) location_1: vec2h, |
| @location(12) @interpolate(flat, center) location_12: vec2f, |
| } |
| |
| struct VertexInput6 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| struct ComputeInput2 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| var<workgroup> vw1: atomic<i32>; |
| |
| @group(0) @binding(10) var<storage, read_write> buffer11: array<array<array<f16, 3>, 512>>; |
| |
| var<workgroup> vw2: array<atomic<u32>, 1>; |
| |
| /* used global variables: buffer10, buffer8 */ |
| fn fn0(a0: vec4<bool>, a1: vec2i, a2: ptr<function, vec2f>) -> u32 { |
| var out: u32; |
| var vf11: f32 = buffer8[0][unconst_u32(2001959669)][unconst_u32(54717938)][unconst_u32(187101228)].location_8[unconst_u32(224632116)]; |
| let ptr1: ptr<uniform, FragmentInput4> = &(*&buffer8)[0][0][2][unconst_u32(412766681)]; |
| out = u32(buffer10[arrayLength(&buffer10)][unconst_u32(23502321)][1][0][u32(buffer10[unconst_i32(263958562)][0][1][0][20])]); |
| let ptr2: ptr<storage, f32, read_write> = &(*&buffer10)[arrayLength(&(*&buffer10))][unconst_u32(1276262732)][1][unconst_u32(2306078884)][20]; |
| let ptr3: ptr<storage, f32, read_write> = &buffer10[unconst_u32(738882874)][unconst_u32(374967987)][1][unconst_u32(426987955)][20]; |
| out |= bitcast<vec2u>((*a2)).g; |
| (*a2) -= vec2f(buffer10[arrayLength(&buffer10)][0][1][0][20]); |
| for (var jj93=0u; jj93<3; jj93++) { buffer10[unconst_u32(968942034)][unconst_u32(206621244)][unconst_u32(152645598)][jj93][20] = atan2(vec4f(unconst_f32(-0.7276e-35), unconst_f32(0.09431), unconst_f32(0.03818e4), unconst_f32(0.3893e-31)), vec4f(unconst_f32(0.08307e-16), unconst_f32(0.04453), unconst_f32(0.00409), unconst_f32(0.08987)))[1]; } |
| let ptr4: ptr<uniform, array<array<array<FragmentInput4, 1>, 3>, 1>> = &(*&buffer8)[unconst_u32(190184686)]; |
| return out; |
| _ = buffer10; |
| _ = buffer8; |
| } |
| |
| struct T2 { |
| @size(88) f0: T0, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(1) var<uniform> buffer8: array<array<array<array<FragmentInput4, 1>, 3>, 1>, 1>; |
| |
| var<private> vp4: u32 = u32(23302684); |
| |
| @group(0) @binding(61) var st2: texture_storage_2d_array<r32uint, read_write>; |
| |
| @group(0) @binding(7) var<storage, read_write> buffer10: array<array<array<array<array<f32, 21>, 1>, 2>, 1>>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T0 { |
| @size(38) f0: array<array<f32, 1>, 1>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(4) var<storage, read> buffer9: array<array<f16, 107>>; |
| |
| struct T3 { |
| @size(16) f0: f16, |
| } |
| |
| struct FragmentInput7 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| struct FragmentInput5 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| struct FragmentInput4 { |
| @location(8) @interpolate(linear, centroid) location_8: vec4f, |
| } |
| |
| @group(0) @binding(308) var st4: texture_storage_1d<r32sint, read_write>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: buffer8, buffer9 */ |
| @vertex |
| fn vertex1(@location(10) location_10: vec2i, a1: VertexInput4, a2: VertexInput5, @location(4) @interpolate(perspective, centroid) location_4: vec4h, @location(8) location_8: vec2i, @location(5) location_5: vec2f, @location(6) @interpolate(linear, centroid) location_6: f32, @location(15) @interpolate(linear) location_15: vec2f, @location(11) location_11: vec4u, @location(13) location_13: vec4i, @location(9) location_9: vec4f, @location(3) @interpolate(flat) location_3: vec2u, a12: VertexInput6, @builtin(instance_index) instance_index: u32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out -= (*&buffer8)[unconst_u32(1782582892)][unconst_u32(286633249)][2][unconst_u32(255617457)].location_8; |
| out = vec4f(buffer8[0][0][unconst_u32(693769602)][0].location_8[unconst_u32(171520132)]); |
| out = vec4f(buffer8[u32(buffer9[unconst_u32(623673591)][106])][unconst_u32(160759905)][2][0].location_8[unconst_u32(33213369)]); |
| let ptr5: ptr<uniform, array<array<array<array<FragmentInput4, 1>, 3>, 1>, 1>> = &buffer8; |
| out *= bitcast<vec4f>(extractBits(vec2i(unconst_i32(392281936), unconst_i32(834173565)), unconst_u32(1382776417), unconst_u32(10124857)).grrr); |
| out = buffer8[0][0][2][0].location_8; |
| out += buffer8[0][unconst_u32(576249965)][unconst_u32(347093539)][0].location_8; |
| var vf12: vec4f = location_9; |
| var vf13: u32 = arrayLength(&(*&buffer9)); |
| var vf14: f32 = (*ptr5)[0][0][2][unconst_u32(134166411)].location_8[unconst_u32(223239230)]; |
| return out; |
| _ = buffer8; |
| _ = buffer9; |
| } |
| |
| /* used global variables: buffer10, buffer11, buffer8, st4 */ |
| @fragment |
| fn fragment2(@builtin(sample_index) sample_index: u32, @location(10) @interpolate(flat) location_10: vec2u, @location(14) location_14: f16, a3: FragmentInput4, a4: FragmentInput5, @location(2) location_2: vec2f, a6: FragmentInput6, @invariant @builtin(position) position: vec4f, a8: FragmentInput7) -> @location(200) @interpolate(linear) vec4i { |
| var out: vec4i; |
| { |
| for (var jj15=0u; jj15<514; jj15++) { buffer11[unconst_u32(2727868187)][jj15][unconst_u32(274281939)] -= f16((*&buffer8)[unconst_u32(544480495)][0][unconst_u32(1035334477)][0].location_8.r); } |
| textureStore(st4, unconst_i32(1020774540), vec4i(vec4i(unconst_i32(458337439), unconst_i32(54693274), unconst_i32(28271337), unconst_i32(273961714)))); |
| out = vec4i(bitcast<i32>((*&buffer10)[unconst_u32(304768520)][unconst_u32(1208266618)][pack4x8unorm(buffer8[0][unconst_u32(314665112)][unconst_u32(460918486)][unconst_u32(245199098)].location_8)][0][unconst_u32(860670981)])); |
| return out; |
| _ = buffer8; |
| _ = buffer10; |
| _ = buffer11; |
| _ = st4; |
| } |
| buffer10[unconst_u32(3217681452)][unconst_u32(859655236)][unconst_u32(706674866)][0][unconst_u32(106423922)] += buffer8[0][unconst_u32(630273999)][2][unconst_u32(68597042)].location_8.a; |
| return out; |
| _ = st4; |
| _ = buffer8; |
| _ = buffer11; |
| _ = buffer10; |
| } |
| |
| /* used global variables: buffer10, buffer14, buffer8, st2 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute1(a0: ComputeInput1, a1: ComputeInput2, @builtin(local_invocation_id) local_invocation_id: vec3u) { |
| let ptr6: ptr<uniform, array<FragmentInput4, 1>> = &buffer8[0][0][unconst_u32(457299166)]; |
| for (var jj70=0u; jj70<15; jj70++) { buffer14[unconst_u32(20450856)][unconst_u32(803147190)][jj70][unconst_u32(45947234)] *= buffer14[unconst_u32(360315158)][31][12][0]; } |
| let ptr7: ptr<uniform, FragmentInput4> = &(*&buffer8)[unconst_u32(268142995)][unconst_u32(1397544263)][2][0]; |
| let ptr8: ptr<uniform, array<array<FragmentInput4, 1>, 3>> = &buffer8[0][0]; |
| let ptr9: ptr<uniform, array<FragmentInput4, 1>> = &(*&buffer8)[0][0][unconst_u32(2553692495)]; |
| vp4 = pack4x8snorm((*ptr9)[0].location_8); |
| textureStore(st2, vec2i(unconst_i32(-92814968), unconst_i32(110061182)), unconst_i32(634057737), vec4u(vec4u((*&buffer8)[unconst_u32(631184180)][0][2][u32(buffer10[arrayLength(&buffer10)][0][1][0][20])].location_8.wyww))); |
| buffer10[unconst_u32(600263447)][unconst_u32(1234079334)][1][unconst_u32(264912048)][u32((*&buffer14)[pack4x8unorm((*&buffer8)[0][unconst_u32(2318848300)][2][0].location_8)][unconst_u32(227997948)][unconst_u32(616519815)][unconst_u32(830710441)])] = buffer8[unconst_u32(180360769)][0][2][0].location_8[0]; |
| _ = buffer10; |
| _ = buffer14; |
| _ = buffer8; |
| _ = st2; |
| }`, |
| }); |
| let textureView15 = texture13.createView({}); |
| let textureView16 = texture6.createView({}); |
| try { |
| computePassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| let buffer15 = device0.createBuffer({size: 2260, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let textureView17 = texture22.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 0, new Float32Array(24185).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4166)), 1823, 0); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer16 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_DST}); |
| let textureView18 = texture20.createView({dimension: '2d', baseArrayLayer: 20}); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer4, 'uint16', 0, 0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| adapter0.label = '\ud688\ueeba\u7303\u1a20\u{1fb3a}'; |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let commandBuffer0 = commandEncoder1.finish(); |
| let textureView19 = texture23.createView({dimension: '2d', baseArrayLayer: 2}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true}); |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup6, new Uint32Array(2143), 104, 0); |
| } catch {} |
| try { |
| computePassEncoder1.insertDebugMarker('\u{1f976}'); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(videoFrame1); |
| let bindGroup7 = device0.createBindGroup({label: '', layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer17 = device0.createBuffer({size: 148, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let textureView20 = texture20.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 36}); |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup5); |
| } catch {} |
| let bindGroup8 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let texture25 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 47}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup8, new Uint32Array(2560), 669, 0); |
| } catch {} |
| try { |
| computePassEncoder3.dispatchWorkgroups(1, 1, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 4, new Uint32Array(2223).map((_, i) => i * 4), 29, 0); |
| } catch {} |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let sampler1 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMinClamp: 64.32, lodMaxClamp: 76.95}); |
| let texture26 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView21 = texture23.createView({dimension: '2d', baseArrayLayer: 2}); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, stencilReadOnly: true}); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer1, 36); }; |
| } catch {} |
| let buffer18 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_DST}); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let texture27 = device0.createTexture({ |
| size: [2760, 1, 1], |
| sampleCount: 4, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 0, new BigInt64Array(12195).map((_, i) => BigInt(i - 9)), 1100, 0); |
| } catch {} |
| let textureView22 = texture27.createView({}); |
| let texture28 = device0.createTexture({ |
| size: [207, 1, 11], |
| mipLevelCount: 3, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer1, 8); }; |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let bindGroup9 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let textureView23 = texture9.createView({baseMipLevel: 0}); |
| let textureView24 = texture8.createView({}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup6, []); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder8.insertDebugMarker('\u0d8b'); |
| } catch {} |
| let pipeline3 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {override4: 1}}}); |
| let textureView25 = texture18.createView({}); |
| let textureView26 = texture19.createView({aspect: 'all', baseMipLevel: 0, arrayLayerCount: 1}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder6.setVertexBuffer(3, buffer3, 348, 134); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 1, y: 112, z: 20}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer19 = device0.createBuffer({size: 64, usage: GPUBufferUsage.INDIRECT, mappedAtCreation: false}); |
| let computePassEncoder4 = commandEncoder7.beginComputePass(); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup2, new Uint32Array(20), 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let textureView27 = texture7.createView({arrayLayerCount: 2}); |
| let computePassEncoder5 = commandEncoder8.beginComputePass(); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup2, new Uint32Array(859), 35, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let buffer20 = device0.createBuffer({size: 135, usage: GPUBufferUsage.INDEX}); |
| let textureView28 = texture0.createView({dimension: '3d', baseArrayLayer: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer6, 'uint32', 16, 21); |
| } catch {} |
| try { |
| commandEncoder0.clearBuffer(buffer16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 96, new Float32Array(3163).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.762)), 19, 36); |
| } catch {} |
| let texture29 = device0.createTexture({ |
| size: [414], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| let textureView29 = texture14.createView({}); |
| let computePassEncoder6 = commandEncoder11.beginComputePass(); |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 0, new DataView(new Uint8Array(4622).map((_, i) => i).buffer), 71, 0); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let textureView30 = texture7.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup3, new Uint32Array(1291), 97, 0); |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder5.label; |
| } catch {} |
| let texture30 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1099}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup5, new Uint32Array(205), 13, 0); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline3); |
| } catch {} |
| await gc(); |
| let bindGroup13 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let textureView31 = texture30.createView({dimension: '3d', aspect: 'all', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(7, buffer6, 40); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| let buffer21 = device0.createBuffer({size: 176, usage: GPUBufferUsage.COPY_SRC}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| let buffer22 = device0.createBuffer({size: 382, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let textureView32 = texture27.createView({aspect: 'all', format: 'bgra8unorm-srgb', mipLevelCount: 1, arrayLayerCount: 1}); |
| let textureView33 = texture9.createView({baseMipLevel: 0}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| let recycledExplicitBindGroupLayout0 = pipeline3.getBindGroupLayout(0); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup12); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 25, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 239, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let autogeneratedBindGroupLayout0 = pipeline2.getBindGroupLayout(0); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let texture31 = device0.createTexture({ |
| size: [207, 1, 406], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView34 = texture21.createView({mipLevelCount: 1}); |
| let computePassEncoder7 = commandEncoder13.beginComputePass(); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer0, 256); }; |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(978).fill(160), /* required buffer size: 978 */ |
| {offset: 978}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let texture32 = device0.createTexture({ |
| size: [345, 1, 30], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup11, new Uint32Array(554), 27, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| buffer16.unmap(); |
| } catch {} |
| let commandEncoder14 = device0.createCommandEncoder(); |
| let texture33 = device0.createTexture({ |
| size: [2760, 1, 1], |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer6, 'uint32', 24, 28); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let textureView35 = texture1.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 3}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup4, new Uint32Array(1743), 850, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer3, 5_144, 46); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToBuffer(buffer21, 80, buffer16, 8, 40); |
| } catch {} |
| let textureView36 = texture23.createView({dimension: '2d-array', baseArrayLayer: 1, arrayLayerCount: 11}); |
| try { |
| device0.queue.writeBuffer(buffer7, 12, new Uint32Array(4861).map((_, i) => i * 1), 516, 0); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(1); |
| let bindGroup14 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let textureView37 = texture16.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(3, bindGroup6, new Uint32Array(2980), 635, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer6, 0, 11); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| adapter0.label = '\u8ed0\u{1f6ec}\u0321'; |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct VertexOutput1 { |
| @location(10) location_10: vec2f, |
| @builtin(position) position: vec4f, |
| @location(6) @interpolate(flat, sample) location_6: i32, |
| @location(1) @interpolate(linear, centroid) location_1: vec4f, |
| } |
| |
| var<workgroup> vw7: array<vec2f, 2>; |
| |
| var<workgroup> vw5: array<array<vec2f, 1>, 1>; |
| |
| var<workgroup> vw8: array<atomic<u32>, 1>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw4: atomic<u32>; |
| |
| struct VertexInput7 { |
| @location(10) location_10: vec4h, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw6: f32; |
| |
| struct T0 { |
| f0: f32, |
| f1: array<array<i32, 3>>, |
| } |
| |
| var<workgroup> vw3: atomic<i32>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex2(@location(7) @interpolate(flat) location_7: u32, a1: VertexInput7, @location(6) @interpolate(linear) location_6: f16, @location(9) location_9: f16) -> VertexOutput1 { |
| var out: VertexOutput1; |
| out.location_6 = i32(pack4xI8Clamp(vec4i(unconst_i32(309823799), unconst_i32(27553571), unconst_i32(54949721), unconst_i32(646235963)))); |
| out.position = vec4f(tan(unconst_f32(-0.2459e-8))); |
| out.location_6 -= i32(out.location_1.y); |
| out.position = out.location_1; |
| var vf15: f32 = out.location_1[unconst_u32(114556682)]; |
| out.position -= vec4f(radians(unconst_f32(0.1733))); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute2() { |
| { |
| atomicAdd(&vw3, unconst_i32(220249479)); |
| atomicXor(&vw8[0], unconst_u32(392649761)); |
| atomicExchange(&vw3, unconst_i32(68742127)); |
| let ptr10: ptr<workgroup, atomic<u32>> = &vw8[unconst_u32(2195107266)]; |
| textureBarrier(); |
| } |
| }`, |
| }); |
| let bindGroup15 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let computePassEncoder8 = commandEncoder10.beginComputePass(); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup6, new Uint32Array(2134), 469, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| let textureView38 = texture23.createView({aspect: 'all', baseArrayLayer: 2, arrayLayerCount: 3}); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer4, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(5, buffer6, 0); |
| } catch {} |
| try { |
| commandEncoder9.insertDebugMarker('\u0622'); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let commandBuffer1 = commandEncoder3.finish(); |
| let texture34 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 82}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView39 = texture26.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup8, new Uint32Array(49), 14, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 188 widthInBlocks: 47 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 72 */ |
| offset: 72, |
| bytesPerRow: 5888, |
| buffer: buffer21, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 42, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 47, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 60, y: 30, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture35 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 4}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer4, 'uint32', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(3, buffer3, 1_052, 789); |
| } catch {} |
| try { |
| buffer6.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '3d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 38, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let recycledExplicitBindGroupLayout2 = pipeline3.getBindGroupLayout(0); |
| let buffer23 = device0.createBuffer({size: 167, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let computePassEncoder9 = commandEncoder14.beginComputePass(); |
| try { |
| device0.queue.writeBuffer(buffer1, 4, new DataView(new ArrayBuffer(18302)), 1454, 8); |
| } catch {} |
| let commandEncoder15 = device0.createCommandEncoder(); |
| let texture36 = device0.createTexture({ |
| size: [345, 1, 1228], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView40 = texture14.createView({aspect: 'all'}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup11, new Uint32Array(921), 40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer6, 20, 41); |
| } catch {} |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let textureView41 = texture25.createView({aspect: 'all', baseMipLevel: 0}); |
| try { |
| computePassEncoder9.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let buffer24 = device0.createBuffer({size: 111, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView42 = texture0.createView({}); |
| try { |
| buffer21.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 0, new Uint16Array(2863).map((_, i) => i + 4), 684, 0); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let computePassEncoder10 = commandEncoder12.beginComputePass(); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer24, 36, buffer16, 200, 0); |
| } catch {} |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 239, resource: {buffer: buffer17}}, |
| {binding: 2, resource: textureView17}, |
| {binding: 25, resource: {buffer: buffer7}}, |
| ], |
| }); |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup11, new Uint32Array(52), 22, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer24, 'uint16', 4, 12); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer24, 36, buffer5, 20, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 51, y: 11, z: 24}, |
| aspect: 'all', |
| }, new Uint8Array(1_014_781).fill(108), /* required buffer size: 1_014_781 */ |
| {offset: 89, bytesPerRow: 217, rowsPerImage: 28}, {width: 25, height: 0, depthOrArrayLayers: 168}); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let computePassEncoder11 = commandEncoder9.beginComputePass(); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline3); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup7, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer23, 8); }; |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline2); |
| } catch {} |
| let textureView43 = texture36.createView({aspect: 'all', arrayLayerCount: 1}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup6, new Uint32Array(327), 19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(3, buffer23, 16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 12, new Float64Array(9111).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/9107)), 606, 0); |
| } catch {} |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let textureView44 = texture13.createView({label: '\udf23'}); |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let computePassEncoder12 = commandEncoder16.beginComputePass(); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(1, buffer3, 0, 1_266); |
| } catch {} |
| let sampler2 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| minFilter: 'linear', |
| lodMaxClamp: 86.66, |
| compare: 'always', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(2, bindGroup8, new Uint32Array(5759), 115, 0); |
| } catch {} |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let texture37 = device0.createTexture({ |
| size: [1], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView45 = texture22.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| commandEncoder18.clearBuffer(buffer7, 8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 4, new Float64Array(12782).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/12780)), 454, 0); |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({label: '', layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: {width: 2760}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(1, buffer6); |
| } catch {} |
| let buffer25 = device0.createBuffer({ |
| size: 78, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let textureView46 = texture23.createView({dimension: '2d', mipLevelCount: 1}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(315), 25, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer23, 4); }; |
| } catch {} |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup2); |
| } catch {} |
| let imageData0 = new ImageData(36, 8); |
| let sampler3 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'repeat'}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup12, new Uint32Array(2688), 661, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer20, 'uint32', 8, 58); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new Uint32Array(1441).map((_, i) => i * 8), 394, 0); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let bindGroup19 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let texture39 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 16}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView47 = texture24.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| try { |
| buffer20.destroy(); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| await gc(); |
| let textureView48 = texture1.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer4, 'uint32', 0, 3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 60, y: 37, z: 89}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| let bindGroup20 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer24, 'uint32', 24, 8); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(7, buffer25, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let commandBuffer2 = commandEncoder6.finish(); |
| let texture40 = device0.createTexture({ |
| size: {width: 828, height: 1, depthOrArrayLayers: 134}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView49 = texture12.createView({}); |
| let sampler4 = device0.createSampler({addressModeV: 'repeat'}); |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 52, y: 0, z: 104}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView50 = texture6.createView({}); |
| let texture41 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 9}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView51 = texture6.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder7.setVertexBuffer(7, buffer23, 12, 18); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 17, y: 19, z: 14}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| struct T6 { |
| f0: array<vec2f>, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T3 { |
| f0: array<array<atomic<i32>, 40>>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw11: atomic<u32>; |
| |
| struct T5 { |
| f0: array<u32>, |
| } |
| |
| var<workgroup> vw9: vec4u; |
| |
| var<workgroup> vw15: array<mat3x2f, 1>; |
| |
| struct T2 { |
| @size(16) f0: atomic<u32>, |
| f1: array<array<array<bool, 1>, 1>>, |
| } |
| |
| /* zero global variables used */ |
| fn fn1(a0: texture_storage_1d<rgba32sint, read>, a1: vec2h) -> array<array<i32, 1>, 1> { |
| var out: array<array<i32, 1>, 1>; |
| let ptr12: ptr<function, i32> = &out[0][0]; |
| var vf16: vec2<bool> = (vec2<bool>(unconst_bool(false), unconst_bool(true)) & vec2<bool>(unconst_bool(true), unconst_bool(true))); |
| let ptr13: ptr<private, array<vec4h, 1>> = &vp5[unconst_u32(649232014)][unconst_u32(498380959)]; |
| vp5[unconst_u32(735336509)][unconst_u32(934021259)][unconst_u32(864025411)] = (*ptr13)[unconst_u32(164547684)]; |
| out[unconst_u32(205438159)][unconst_u32(157269941)] ^= i32(vf16[unconst_u32(2449523801)]); |
| vp5[unconst_u32(1131705037)][unconst_u32(166510764)][unconst_u32(381463164)] = (*ptr13)[0]; |
| return out; |
| } |
| |
| var<private> vp5: array<array<array<vec4h, 1>, 4>, 1> = array(array(array<vec4h, 1>(vec4h(1916.6, 13098.4, 5289.6, 6272.6)), array(vec4h(3411.9, 7735.9, 13997.7, 963.9)), array<vec4h, 1>(), array<vec4h, 1>(vec4h(22200.0, 22005.8, 30398.2, 19428.8)))); |
| |
| /* zero global variables used */ |
| fn fn0(a0: array<array<array<vec2h, 1>, 1>, 1>, a1: ptr<workgroup, atomic<u32>>, a2: ptr<workgroup, atomic<i32>>, a3: vec2i) { |
| let ptr11: ptr<private, array<vec4h, 1>> = &vp5[unconst_u32(2138083756)][3]; |
| atomicMin(&(*a2), vec4i(vp5[unconst_u32(327193231)][3][0]).y); |
| atomicMax(&(*a1), unconst_u32(562115267)); |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(1) @binding(93) var st7: texture_storage_1d<rgba32sint, read>; |
| |
| @group(0) @binding(93) var st6: texture_storage_1d<rgba32sint, read>; |
| |
| var<workgroup> vw12: array<atomic<u32>, 1>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw10: array<atomic<i32>, 1>; |
| |
| var<workgroup> vw13: atomic<u32>; |
| |
| struct T1 { |
| f0: array<vec4h>, |
| } |
| |
| struct FragmentOutput1 { |
| @location(5) @interpolate(flat, center) location_5: vec4i, |
| @location(0) @interpolate(flat) location_0: vec4i, |
| } |
| |
| struct T7 { |
| f0: array<vec4f>, |
| } |
| |
| /* used global variables: st6, st7 */ |
| fn fn2() { |
| let ptr14: ptr<private, vec4h> = &vp5[unconst_u32(1267706988)][3][unconst_u32(40857604)]; |
| var vf17: vec3i = firstTrailingBit(vec3i(unconst_i32(427675155), unconst_i32(171638504), unconst_i32(667426459))); |
| vp5[unconst_u32(534990613)][unconst_u32(280162548)][unconst_u32(21307163)] *= bitcast<vec4h>(log2(vec2f(unconst_f32(0.1983e-33), unconst_f32(-0.4007)))); |
| vf17 = vec3i(log2(bitcast<vec2f>(vp5[0][3][0])).rgr); |
| _ = fn1(st7, vp5[unconst_u32(12491638)][3][0].zy); |
| fn1(st6, vp5[unconst_u32(350937403)][unconst_u32(317121651)][unconst_u32(673052288)].xx); |
| let vf18: f16 = vp5[0][3][0][unconst_u32(1357254636)]; |
| var vf19: f16 = vp5[unconst_u32(764693432)][3][unconst_u32(310470552)][unconst_u32(733901442)]; |
| var vf20: f16 = vp5[0][unconst_u32(133745634)][unconst_u32(71478873)][unconst_u32(416170764)]; |
| for (var it0=u32((*ptr14).x); it0<(u32(vp5[unconst_u32(1021977536)][unconst_u32(377038438)][0][3]) & 0xfff); it0++) { |
| vp5[unconst_u32(375720983)][3][unconst_u32(257747285)] = vec4h(f16(quantizeToF16(unconst_f32(-0.2381e18)))); |
| let ptr15: ptr<private, vec4h> = &vp5[unconst_u32(1085420317)][unconst_u32(857122517)][unconst_u32(856817846)]; |
| fn1(st6, atan2(vec4h(unconst_f16(5143.9), unconst_f16(74.49), unconst_f16(7039.1), unconst_f16(12232.0)), vec4h(unconst_f16(-29542.4), unconst_f16(18340.4), unconst_f16(4214.4), unconst_f16(34962.3))).rb); |
| _ = st6; |
| } |
| _ = st7; |
| _ = st6; |
| } |
| |
| struct T4 { |
| @align(32) f0: array<atomic<u32>>, |
| } |
| |
| var<workgroup> vw14: array<vec4u, 1>; |
| |
| struct T0 { |
| @size(64) f0: vec2u, |
| f1: array<u32>, |
| } |
| |
| /* used global variables: st7 */ |
| @fragment |
| fn fragment3() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let vf21: vec3i = (vec3i(unconst_i32(133778481), unconst_i32(519548276), unconst_i32(12541355)) >> vec3u(unconst_u32(785660211), unconst_u32(1087833074), unconst_u32(1505174498))); |
| let vf22: u32 = textureDimensions(st7); |
| return out; |
| _ = st7; |
| }`, |
| }); |
| let bindGroup21 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer26 = device0.createBuffer({ |
| size: 52, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline2); |
| } catch {} |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let texture42 = device0.createTexture({ |
| size: {width: 207, height: 1, depthOrArrayLayers: 50}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup9, new Uint32Array(3757), 185, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(2, buffer25, 0, 9); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 4, new DataView(new ArrayBuffer(11628)), 160, 0); |
| } catch {} |
| let imageData1 = new ImageData(20, 92); |
| let buffer27 = device0.createBuffer({size: 284, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let computePassEncoder13 = commandEncoder10.beginComputePass(); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup3, new Uint32Array(8342), 76, 0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer4, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 93, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 5, y: 8, z: 7}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 28, height: 29, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout3 = pipeline0.getBindGroupLayout(0); |
| let buffer28 = device0.createBuffer({size: 197, usage: GPUBufferUsage.UNIFORM}); |
| let textureView52 = texture26.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let textureView53 = texture24.createView({dimension: '2d-array', baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let texture43 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder6.setVertexBuffer(0, buffer25, 20, 0); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 89, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 26, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let autogeneratedBindGroupLayout1 = pipeline2.getBindGroupLayout(1); |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer24, 'uint32', 56, 7); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 32, new Float32Array(8316).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.977)), 2732, 0); |
| } catch {} |
| document.body.append(canvas0); |
| let imageBitmap1 = await createImageBitmap(imageData0); |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new Float64Array(7398).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/7396)), 95, 0); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer4, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline2); |
| } catch {} |
| let texture44 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView54 = texture14.createView({}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer24, 'uint32', 4, 39); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(2, buffer23); |
| } catch {} |
| try { |
| buffer26.unmap(); |
| } catch {} |
| let imageData2 = new ImageData(56, 48); |
| let bindGroup22 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView1}]}); |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer4, 'uint16', 0, 2); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToBuffer(buffer24, 72, buffer1, 4, 0); |
| } catch {} |
| let texture45 = device0.createTexture({ |
| size: [4, 4, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup13, new Uint32Array(4529), 8, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 0, new BigInt64Array(8281).map((_, i) => BigInt(i - 7)), 276, 0); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline2); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture2.label; |
| } catch {} |
| let recycledExplicitBindGroupLayout4 = pipeline1.getBindGroupLayout(0); |
| let bindGroup23 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup5, new Uint32Array(2604), 57, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer23, 28, 77); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 249}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 61, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 116, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let textureView55 = texture15.createView({mipLevelCount: 1}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let commandEncoder25 = device0.createCommandEncoder({label: '\u098d\u0544\u09fb\u80d7'}); |
| let texture46 = device0.createTexture({ |
| size: {width: 2}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder13.setPipeline(pipeline2); |
| } catch {} |
| await gc(); |
| let textureView56 = texture11.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup3, new Uint32Array(6427), 574, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(1, bindGroup17, new Uint32Array(1461), 123, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(3, buffer6, 0, 35); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup25 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let texture47 = device0.createTexture({ |
| size: {width: 1380, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer18, 48, new Float16Array(6304).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 1.170)), 1429, 0); |
| } catch {} |
| let imageData3 = new ImageData(48, 52); |
| let textureView57 = texture25.createView({baseMipLevel: 0}); |
| try { |
| renderBundleEncoder6.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 4, new DataView(new Uint8Array(1890).map((_, i) => i).buffer), 193, 8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 2, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 34, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer3 = commandEncoder12.finish(); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup19, new Uint32Array(2050), 249, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 44, new Uint32Array(9723).map((_, i) => i * 1), 9270, 0); |
| } catch {} |
| let buffer29 = device0.createBuffer({size: 168, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| try { |
| renderBundleEncoder8.setVertexBuffer(5, buffer23, 12); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroup26 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer30 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_DST}); |
| let texture48 = device0.createTexture({ |
| size: [1380, 1, 54], |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer4, 'uint16', 0, 3); |
| } catch {} |
| let texture49 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup13, new Uint32Array(1563), 47, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| let textureView58 = texture12.createView({dimension: '2d-array'}); |
| try { |
| commandEncoder24.copyTextureToTexture({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 106, y: 0, z: 59}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 44, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 44, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder11.insertDebugMarker('\u9a48'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 0, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 7, y: 66, z: 24}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 20, height: 24, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let textureView59 = texture34.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer6, 'uint32', 4, 6); |
| } catch {} |
| let imageData4 = new ImageData(12, 40); |
| let computePassEncoder14 = commandEncoder5.beginComputePass(); |
| try { |
| computePassEncoder14.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder0.copyBufferToBuffer(buffer24, 28, buffer4, 0, 0); |
| } catch {} |
| let bindGroup27 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let texture50 = device0.createTexture({ |
| size: [828, 1, 13], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder11.setPipeline(pipeline3); |
| } catch {} |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let texture51 = device0.createTexture({ |
| size: [1, 1, 36], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture52 = device0.createTexture({ |
| size: [345], |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let bindGroup28 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer31 = device0.createBuffer({size: 36, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let texture53 = device0.createTexture({size: [256, 256, 19], format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView60 = texture33.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(2, bindGroup2, new Uint32Array(1047), 175, 0); |
| } catch {} |
| let promise6 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm16x2', offset: 620, shaderLocation: 14}, |
| {format: 'uint16x4', offset: 160, shaderLocation: 2}, |
| {format: 'float32', offset: 44, shaderLocation: 1}, |
| {format: 'float32x2', offset: 16, shaderLocation: 6}, |
| {format: 'snorm8x4', offset: 308, shaderLocation: 9}, |
| {format: 'sint16x2', offset: 412, shaderLocation: 10}, |
| {format: 'float32', offset: 208, shaderLocation: 12}, |
| {format: 'snorm8x2', offset: 252, shaderLocation: 15}, |
| {format: 'uint32x4', offset: 196, shaderLocation: 11}, |
| {format: 'sint8x4', offset: 112, shaderLocation: 13}, |
| {format: 'snorm16x4', offset: 780, shaderLocation: 0}, |
| {format: 'unorm8x4', offset: 200, shaderLocation: 5}, |
| {format: 'uint32', offset: 24, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 16, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 0, shaderLocation: 8}, |
| {format: 'snorm16x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint32', offset: 0, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let buffer32 = device0.createBuffer({ |
| size: 668, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder28 = device0.createCommandEncoder({label: ''}); |
| let textureView61 = texture6.createView({}); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 54.86, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer24, 'uint16', 22, 3); |
| } catch {} |
| try { |
| renderBundleEncoder12.setPipeline(pipeline2); |
| } catch {} |
| try { |
| adapter1.label = ''; |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let sampler6 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 86.09}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 11, y: 12 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 119, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout5 = pipeline0.getBindGroupLayout(0); |
| let bindGroup29 = device0.createBindGroup({ |
| label: '\u{1ffd2}', |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 93, resource: textureView5}], |
| }); |
| let commandBuffer4 = commandEncoder23.finish(); |
| try { |
| renderBundleEncoder5.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer4, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 31, y: 56, z: 19}, |
| aspect: 'all', |
| }, new Uint8Array(304_814).fill(213), /* required buffer size: 304_814 */ |
| {offset: 262, bytesPerRow: 168, rowsPerImage: 66}, {width: 17, height: 31, depthOrArrayLayers: 28}); |
| } catch {} |
| let pipeline4 = await promise6; |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({ |
| size: [690, 1, 53], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup9, new Uint32Array(6809), 2_583, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.insertDebugMarker('\u{1ffb5}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 4, new Uint32Array(14612).map((_, i) => i * 6), 1112, 4); |
| } catch {} |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'jedecP22Phosphors', transfer: 'unspecified'} }); |
| let videoFrame6 = new VideoFrame(videoFrame1, {timestamp: 0}); |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 59, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 61, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 109, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 153, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 308, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 312, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 524, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView62 = texture12.createView({label: '\ub219\u54ff\u3313\u76d9\u6e7b\uc91e\u24e2\u5e90', dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(0, bindGroup15, new Uint32Array(343), 139, 0); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 4, new DataView(new ArrayBuffer(2788)), 46, 32); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(133).fill(16), /* required buffer size: 133 */ |
| {offset: 133}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline5 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x39df22f5}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| {arrayStride: 580, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 96, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint16x4', offset: 12, shaderLocation: 15}, |
| {format: 'float16x4', offset: 24, shaderLocation: 5}, |
| {format: 'float32', offset: 12, shaderLocation: 2}, |
| {format: 'uint16x2', offset: 8, shaderLocation: 4}, |
| {format: 'sint8x2', offset: 58, shaderLocation: 13}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 12}, |
| {format: 'float32x2', offset: 16, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 20, shaderLocation: 8}, |
| {format: 'uint8x4', offset: 44, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 6, shaderLocation: 10}, |
| {format: 'snorm8x2', offset: 8, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 12, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let bindGroup30 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout5, entries: [{binding: 93, resource: textureView1}]}); |
| let commandBuffer5 = commandEncoder11.finish(); |
| let textureView63 = texture39.createView({format: 'rgba16sint', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer24, 'uint32', 16, 6); |
| } catch {} |
| try { |
| commandEncoder0.copyTextureToTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 51}, |
| aspect: 'all', |
| }, |
| {width: 139, height: 0, depthOrArrayLayers: 34}); |
| } catch {} |
| try { |
| commandEncoder29.insertDebugMarker('\u845e'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| await gc(); |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let computePassEncoder15 = commandEncoder26.beginComputePass(); |
| try { |
| computePassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| let textureView64 = texture34.createView({mipLevelCount: 1}); |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup17); |
| } catch {} |
| let imageData5 = new ImageData(76, 20); |
| try { |
| globalThis.someLabel = sampler0.label; |
| } catch {} |
| let textureView65 = texture41.createView({}); |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer6, 'uint16', 10, 26); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 28, new DataView(new ArrayBuffer(25384)), 1018, 4); |
| } catch {} |
| let buffer33 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup23, new Uint32Array(91), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer6, 'uint32', 12, 62); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let bindGroup31 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer34 = device0.createBuffer({size: 132, usage: GPUBufferUsage.STORAGE}); |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup27, new Uint32Array(112), 7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer6, 'uint32', 0, 10); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 592 */ |
| offset: 592, |
| bytesPerRow: 15616, |
| buffer: buffer32, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 36, new DataView(new ArrayBuffer(7420)), 335, 52); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 176, y: 0, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(53).fill(15), /* required buffer size: 53 */ |
| {offset: 53}, {width: 238, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 402, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let textureView66 = texture51.createView({aspect: 'all', format: 'rg8uint', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer4, 'uint16', 2, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.pushDebugGroup('\u0a0d'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 36, new Float16Array(1093).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 0.8395)), 208, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(21).fill(115), /* required buffer size: 21 */ |
| {offset: 21}, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 65, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 97, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 41, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let computePassEncoder16 = commandEncoder19.beginComputePass(); |
| try { |
| renderBundleEncoder7.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| renderBundleEncoder5.popDebugGroup(); |
| } catch {} |
| let buffer35 = device0.createBuffer({size: 508, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let texture55 = device0.createTexture({ |
| size: [1380, 1, 1], |
| sampleCount: 1, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder17 = commandEncoder21.beginComputePass(); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup8, new Uint32Array(171), 16, 0); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder33 = device0.createCommandEncoder({label: '\u6142'}); |
| let texture56 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 21}, |
| mipLevelCount: 3, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder17.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 12, new Uint32Array(21832).map((_, i) => i * 2), 10138, 8); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fc76}\u2126\u613d\u{1fc81}\u000d\u0880'; |
| } catch {} |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let texture57 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 91}, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView67 = texture14.createView({}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: false, stencilReadOnly: true}); |
| try { |
| device0.queue.writeBuffer(buffer29, 4, new DataView(new Uint8Array(44603).map((_, i) => i).buffer), 1686, 24); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup32 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer36 = device0.createBuffer({ |
| size: 32, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let textureView68 = texture46.createView({aspect: 'all'}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| let texture58 = device0.createTexture({ |
| size: [8, 8, 24], |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let texture59 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView69 = texture14.createView({dimension: '2d-array'}); |
| let computePassEncoder18 = commandEncoder24.beginComputePass(); |
| try { |
| buffer34.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let pipeline6 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x1d16fe0b}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{ |
| format: 'rgba16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 148, shaderLocation: 9}, |
| {format: 'float32x4', offset: 68, shaderLocation: 6}, |
| {format: 'unorm16x2', offset: 132, shaderLocation: 10}, |
| {format: 'uint32x2', offset: 92, shaderLocation: 7}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'front'}, |
| }); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 8, new Float32Array(8879).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.026)), 20, 0); |
| } catch {} |
| let bindGroup33 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer37 = device0.createBuffer({size: 20, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder18.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer24, 'uint32', 16, 1); |
| } catch {} |
| document.body.prepend(canvas1); |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let textureView70 = texture31.createView({}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 2, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(311).fill(239), /* required buffer size: 311 */ |
| {offset: 311}, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {override4: 1}}}); |
| try { |
| await promise8; |
| } catch {} |
| let buffer38 = device0.createBuffer({ |
| size: 28, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| renderBundleEncoder9.setPipeline(pipeline5); |
| } catch {} |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let textureView71 = texture46.createView({}); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], sampleCount: 1}); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup27, new Uint32Array(1876), 1_192, 0); |
| } catch {} |
| let recycledExplicitBindGroupLayout6 = pipeline1.getBindGroupLayout(0); |
| let bindGroup34 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]}); |
| let textureView72 = texture51.createView({mipLevelCount: 1}); |
| let renderPassEncoder0 = commandEncoder35.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: -219.1, g: -387.5, b: 834.7, a: 686.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(3, buffer26, 0, 2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 0, new DataView(new ArrayBuffer(2750)), 38, 0); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup35 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout5, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let texture60 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup8, new Uint32Array(305), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(2, bindGroup6, new Uint32Array(8855), 1_610, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| } catch {} |
| let gpuCanvasContext1 = canvas1.getContext('webgpu'); |
| document.body.prepend(canvas1); |
| let texture61 = device0.createTexture({ |
| size: [2, 2, 1], |
| mipLevelCount: 1, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder1 = commandEncoder18.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: -747.1, g: -112.7, b: -372.1, a: -882.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup29, new Uint32Array(2692), 192, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer38, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(4, buffer23, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(91).fill(91), /* required buffer size: 91 */ |
| {offset: 91}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder37 = device0.createCommandEncoder(); |
| let computePassEncoder19 = commandEncoder0.beginComputePass(); |
| try { |
| computePassEncoder19.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(0, buffer36, 8, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 136, new DataView(new ArrayBuffer(51888)), 871, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 200, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let textureView73 = texture6.createView({baseMipLevel: 0}); |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer36, 'uint32', 12, 2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup27, new Uint32Array(510), 249, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(1, bindGroup19, new Uint32Array(2066), 252, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let commandEncoder38 = device0.createCommandEncoder(); |
| let textureView74 = texture16.createView({format: 'r32sint'}); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup10, new Uint32Array(621), 49, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setStencilReference(357); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(6, buffer23, 0, 27); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| struct VertexInput9 { |
| @location(10) @interpolate(flat) location_10: u32, |
| @location(8) location_8: vec2h, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T1 { |
| @align(16) f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| struct VertexInput8 { |
| @location(3) @interpolate(flat) location_3: i32, |
| @location(4) @interpolate(flat) location_4: i32, |
| } |
| |
| struct VertexInput11 { |
| @location(7) location_7: vec2f, |
| @location(1) @interpolate(flat, first) location_1: vec4u, |
| @location(11) @interpolate(flat) location_11: vec2u, |
| } |
| |
| struct ComputeInput3 { |
| @builtin(local_invocation_id) local_invocation_id: vec3u, |
| } |
| |
| struct VertexInput12 { |
| @location(15) @interpolate(flat) location_15: vec2u, |
| } |
| |
| @group(0) @binding(7) var<storage, read> buffer40: array<array<f16, 2>, 96>; |
| |
| @group(0) @binding(116) var<storage, read_write> buffer41: array<array<array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 1>, 23>, 1>, 1>, 8>>; |
| |
| struct VertexInput15 { |
| @builtin(vertex_index) vertex_index: u32, |
| } |
| |
| @group(0) @binding(60) var tex4: texture_multisampled_2d<i32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T3 { |
| @size(1456) f0: atomic<i32>, |
| } |
| |
| struct VertexInput14 { |
| @location(5) location_5: vec4h, |
| } |
| |
| struct T2 { |
| f0: array<atomic<i32>>, |
| } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| var<workgroup> vw16: vec2i; |
| |
| var<workgroup> vw18: array<array<array<array<vec4h, 5>, 4>, 1>, 1>; |
| |
| struct VertexOutput2 { |
| @location(3) @interpolate(flat, centroid) location_3: vec2h, |
| @location(8) location_8: f32, |
| @invariant @builtin(position) position: vec4f, |
| @location(14) @interpolate(flat, centroid) location_14: vec2i, |
| @location(2) location_2: vec2u, |
| @location(4) location_4: vec4i, |
| } |
| |
| struct T4 { |
| f0: array<array<vec2f, 2>>, |
| } |
| |
| struct VertexInput10 { |
| @location(14) @interpolate(linear, first) location_14: vec4h, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<workgroup> vw19: vec2<bool>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw17: atomic<i32>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct VertexInput13 { |
| @location(2) location_2: vec2u, |
| } |
| |
| /* used global variables: buffer40, tex4 */ |
| @vertex |
| fn vertex3(a0: VertexInput8, a1: VertexInput9, a2: VertexInput10, a3: VertexInput11, @location(13) location_13: vec4u, @location(9) location_9: vec4u, @location(6) @interpolate(perspective, first) location_6: vec2h, @location(0) @interpolate(flat) location_0: vec2h, a8: VertexInput12, a9: VertexInput13, @location(12) location_12: vec4h, a11: VertexInput14, a12: VertexInput15, @builtin(instance_index) instance_index: u32) -> VertexOutput2 { |
| var out: VertexOutput2; |
| let ptr16: ptr<storage, array<f16, 2>, read> = &(*&buffer40)[unconst_u32(59716463)]; |
| var vf23: bool = any(vec2<bool>(unconst_bool(false), unconst_bool(false))); |
| let ptr17: ptr<storage, array<f16, 2>, read> = &(*&buffer40)[95]; |
| out.position = vec4f(a8.location_15.xyxx); |
| out.position = vec4f(reflect(vec4h(unconst_f16(-6167.1), unconst_f16(-87.43), unconst_f16(15918.4), unconst_f16(5352.5)), vec4h(unconst_f16(736.5), unconst_f16(30524.0), unconst_f16(21315.6), unconst_f16(4399.7))).ywxy); |
| out.location_3 += bitcast<vec2h>(a3.location_11[unconst_u32(208827852)]); |
| out.position *= vec4f(f32(buffer40[95][1])); |
| var vf24: f16 = cos(unconst_f16(877.5)); |
| vf23 = bool(textureDimensions(tex4)[0]); |
| let ptr18: ptr<storage, f16, read> = &(*&buffer40)[95][1]; |
| return out; |
| _ = buffer40; |
| _ = tex4; |
| } |
| |
| /* used global variables: buffer41 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute3(a0: ComputeInput3, @builtin(global_invocation_id) global_invocation_id: vec3u, @builtin(num_workgroups) num_workgroups: vec3u, @builtin(workgroup_id) workgroup_id: vec3u, @builtin(local_invocation_index) local_invocation_index: u32) { |
| let ptr19: ptr<workgroup, vec4h> = &(*&vw18)[unconst_u32(1601756889)][0][3][4]; |
| let ptr20: ptr<storage, f16, read_write> = &buffer41[arrayLength(&buffer41)][unconst_u32(504271322)][unconst_u32(693014012)][unconst_u32(1049967045)][unconst_u32(720105791)][unconst_u32(867827880)][0][unconst_u32(783811190)][0]; |
| vw18[unconst_u32(394354723)][unconst_u32(404690683)][unconst_u32(290190671)][unconst_u32(1305566375)] *= vec4h((*&buffer41)[arrayLength(&(*&buffer41))][unconst_u32(645864597)][0][0][22][unconst_u32(163500864)][unconst_u32(818462862)][0][0]); |
| for (var jj84=0u; jj84<6; jj84++) { vw18[unconst_u32(78264059)][unconst_u32(530498517)][jj84][unconst_u32(225720447)] += vec4h((*&buffer41)[unconst_u32(191585141)][7][unconst_u32(3115362690)][unconst_u32(406242004)][22][unconst_u32(1149668495)][u32(buffer41[arrayLength(&buffer41)][unconst_u32(2432215391)][0][u32((*&buffer41)[arrayLength(&(*&buffer41))][7][unconst_u32(381412990)][0][unconst_u32(1115311470)][0][0][unconst_u32(343390694)][0])][unconst_u32(1003846851)][0][0][0][unconst_u32(1076972753)])][unconst_u32(287727296)][unconst_u32(877025309)]); } |
| vw19 = vec2<bool>(bool((*&buffer41)[unconst_u32(1271669102)][7][0][0][u32(buffer41[arrayLength(&buffer41)][7][0][unconst_u32(869248787)][22][unconst_u32(1011746422)][unconst_u32(84001523)][unconst_u32(84253691)][0])][0][0][0][0])); |
| return; |
| _ = buffer41; |
| }`, |
| }); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let textureView75 = texture25.createView({}); |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer38, 0, 9); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let buffer42 = device0.createBuffer({size: 116, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup17, new Uint32Array(193), 9, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(0, bindGroup27); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer38, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 29, y: 21, z: 41}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup36 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: []}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer38, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup36, []); |
| } catch {} |
| try { |
| renderBundleEncoder0.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder37.copyBufferToBuffer(buffer42, 72, buffer1, 32, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 8, y: 39 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 399, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer4, 'uint16', 0, 2); |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let textureView76 = texture13.createView({}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer24, 'uint16', 16, 39); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup37 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer43 = device0.createBuffer({size: 248, usage: GPUBufferUsage.COPY_SRC}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup34, new Uint32Array(98), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer35, 'uint16', 78, 65); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer6, 'uint32', 4, 3); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture62 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 42}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer38, 0); |
| } catch {} |
| let pipeline8 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0xffffffff}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.BLUE}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| {arrayStride: 4, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 768, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x4', offset: 340, shaderLocation: 15}, |
| {format: 'float32x3', offset: 232, shaderLocation: 11}, |
| {format: 'sint8x4', offset: 296, shaderLocation: 8}, |
| {format: 'unorm8x2', offset: 30, shaderLocation: 14}, |
| {format: 'unorm16x2', offset: 44, shaderLocation: 10}, |
| {format: 'float32x2', offset: 148, shaderLocation: 2}, |
| {format: 'uint16x4', offset: 96, shaderLocation: 4}, |
| {format: 'unorm16x2', offset: 172, shaderLocation: 12}, |
| {format: 'uint16x4', offset: 180, shaderLocation: 7}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 13}, |
| ], |
| }, |
| { |
| arrayStride: 148, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x2', offset: 4, shaderLocation: 9}, {format: 'unorm8x2', offset: 8, shaderLocation: 5}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 59, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 61, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 109, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 153, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 308, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 312, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 524, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture63 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 27}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup6, new Uint32Array(496), 105, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline6); |
| } catch {} |
| let commandEncoder42 = device0.createCommandEncoder(); |
| let sampler7 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 51.68, |
| lodMaxClamp: 97.44, |
| }); |
| let textureView77 = texture47.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup8, new Uint32Array(2096), 435, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup21, new Uint32Array(3), 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(7, buffer35); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let buffer44 = device0.createBuffer({size: 80, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder30.copyBufferToBuffer(buffer42, 24, buffer23, 40, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 16, new DataView(new Uint8Array(18682).map((_, i) => i).buffer), 11332, 0); |
| } catch {} |
| await gc(); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer35, 'uint32', 132, 142); |
| } catch {} |
| document.body.append(canvas1); |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let textureView78 = texture57.createView({aspect: 'all'}); |
| let renderPassEncoder2 = commandEncoder4.beginRenderPass({colorAttachments: [{view: textureView46, loadOp: 'load', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(0, buffer3, 0, 1_238); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup23, new Uint32Array(610), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer35, 'uint32', 44, 178); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let renderPassEncoder3 = commandEncoder22.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: -448.5, g: 436.4, b: 328.8, a: 95.73, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer24, 'uint16', 30, 9); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 0, new DataView(new ArrayBuffer(58552)), 3444, 0); |
| } catch {} |
| let buffer45 = device0.createBuffer({ |
| label: '\u024a\u1c01\u04ab', |
| size: 104, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer35, 'uint32', 8, 55); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup36, new Uint32Array(4933), 149, 0); |
| } catch {} |
| let renderPassEncoder4 = commandEncoder15.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: -782.8, g: -195.8, b: -41.67, a: -487.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 78742919, |
| }); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer36, 'uint32', 0, 2); |
| } catch {} |
| try { |
| buffer45.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 121, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(52).fill(138), /* required buffer size: 52 */ |
| {offset: 52}, {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -319.7, g: -652.1, b: 37.49, a: -895.3, }); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer38, 0, 3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 226, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let buffer46 = device0.createBuffer({size: 5696, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder45 = device0.createCommandEncoder(); |
| let sampler8 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'linear', lodMaxClamp: 62.30}); |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer4, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, buffer26, 4, 2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer36, 'uint32', 0, 9); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 28, new Float32Array(5149).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.753)), 1419, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 70, y: 22 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 58, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline9 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let pipeline10 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0xffffffff}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 268, |
| attributes: [ |
| {format: 'unorm8x4', offset: 24, shaderLocation: 6}, |
| {format: 'uint32', offset: 4, shaderLocation: 7}, |
| {format: 'float32x3', offset: 100, shaderLocation: 10}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let textureView79 = texture23.createView({dimension: '2d', baseArrayLayer: 5}); |
| let renderPassEncoder5 = commandEncoder36.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: 946.4, g: -417.3, b: -929.8, a: 733.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 38529395, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup38, new Uint32Array(2554), 416, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.drawIndirect(buffer19, 24); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(2, buffer38, 0, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 4, new Float32Array(13836).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.7858)), 3692, 4); |
| } catch {} |
| await gc(); |
| let textureView80 = texture56.createView({dimension: '2d', mipLevelCount: 2, baseArrayLayer: 10}); |
| let texture64 = device0.createTexture({ |
| size: [256, 256, 76], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| let renderBundle0 = renderBundleEncoder12.finish({}); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(1, buffer25, 20); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(3, buffer36, 0, 3); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| document.body.append(canvas1); |
| let textureView81 = texture21.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer38, 4, 2); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder47 = device0.createCommandEncoder(); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer45, 'uint16', 4, 23); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer3, 1_056); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(imageBitmap1); |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], sampleCount: 1, depthReadOnly: false}); |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer35, 'uint32', 32, 131); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(4, buffer45, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer18, 12, new Uint32Array(17729).map((_, i) => i * 1), 5309, 0); |
| } catch {} |
| let buffer47 = device0.createBuffer({label: '', size: 24, usage: GPUBufferUsage.COPY_DST}); |
| let textureView82 = texture49.createView({}); |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer35, 'uint16', 0, 42); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(5, buffer3, 1_076, 1_704); |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| @group(0) @binding(4) var<storage, read> buffer49: array<array<array<array<f16, 107>, 1>, 1>>; |
| |
| @id(46114) override override5: f32; |
| |
| struct FragmentInput10 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| @group(0) @binding(49) var<storage, read_write> buffer52: vec4i; |
| |
| @group(0) @binding(153) var<storage, read_write> buffer54: array<array<FragmentInput8, 1>, 26>; |
| |
| @group(0) @binding(312) var sam4: sampler_comparison; |
| |
| struct FragmentOutput3 { |
| @location(0) location_0: vec4i, |
| } |
| |
| struct T1 { |
| @align(16) f0: array<u32>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct FragmentOutput4 { |
| @location(3) @interpolate(flat, centroid) location_3: i32, |
| @location(6) @interpolate(flat, center) location_6: vec2i, |
| @location(0) location_0: vec4u, |
| } |
| |
| struct FragmentOutput2 { |
| @location(0) @interpolate(flat, center) location_0: vec4i, |
| @location(1) location_1: i32, |
| } |
| |
| @group(0) @binding(10) var<storage, read_write> buffer51: array<array<array<array<array<array<f16, 1>, 2>, 3>, 128>, 2>>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: buffer49 */ |
| fn fn0(a0: bool) -> array<array<array<vec2h, 1>, 1>, 5> { |
| var out: array<array<array<vec2h, 1>, 1>, 5>; |
| let vf25: vec2h = fma(vec2h(unconst_f16(9802.2), unconst_f16(36962.7)), vec2h(unconst_f16(4107.8), unconst_f16(66.63)), vec2h(unconst_f16(208.9), unconst_f16(1841.4))); |
| let ptr21: ptr<storage, f16, read> = &(*&buffer49)[unconst_u32(511642499)][0][0][unconst_u32(123356333)]; |
| out[unconst_u32(97023600)][unconst_u32(4294967295)][unconst_u32(323326778)] -= bitcast<vec2h>(pack4x8snorm(vec4f(unconst_f32(0.5167), unconst_f32(0.4044), unconst_f32(0.2612), unconst_f32(0.1166)))); |
| out[unconst_u32(951188550)][unconst_u32(544257865)][0] = vec2h((*&buffer49)[arrayLength(&(*&buffer49))][0][0][106]); |
| let ptr22: ptr<storage, f16, read> = &(*&buffer49)[unconst_u32(583374892)][unconst_u32(34009293)][0][106]; |
| return out; |
| _ = buffer49; |
| } |
| |
| struct T4 { |
| f0: array<array<array<atomic<i32>, 1>, 1>>, |
| } |
| |
| @group(0) @binding(7) var<storage, read_write> buffer50: array<array<vec2i, 21>>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @id(23593) override override6 = true; |
| |
| /* used global variables: sam4 */ |
| fn fn1() { |
| let vf26: vec3f = degrees(vec3f(unconst_f32(0.1205), unconst_f32(0.1605e-2), unconst_f32(0.3256))); |
| var vf27: vec3f = vf26; |
| vf27 = vec3f(vf26[unconst_u32(1398826703)]); |
| vf27 += vf27; |
| let vf28: vec3i = countTrailingZeros(vec3i(i32(override5))); |
| for (var it1=pack2x16snorm(vec2f(unconst_f32(-0.02401), unconst_f32(0.2034))); it1<(u32( !bool( -vec2h(unconst_f16(14811.2), unconst_f16(3550.8)).g)) & 0xfff); it1++) { |
| _ = sam4; |
| _ = sam4; |
| } |
| let vf29: f32 = vf27[unconst_u32(1480325548)]; |
| vf27 = vec3f(bitcast<f32>(pack2x16snorm(vec2f(unconst_f32(0.02411e-6), unconst_f32(0.2033))))); |
| var vf30: vec3f = ldexp(vec3f(unconst_f32(0.4570e-13), unconst_f32(-0.08213e4), unconst_f32(0.02571)), vec3i(unconst_i32(224810645), unconst_i32(156401543), unconst_i32(132945416))); |
| var vf31: vec3i = vf28; |
| _ = override5; |
| _ = sam4; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T2 { |
| f0: array<array<array<u32, 1>, 12>, 1>, |
| } |
| |
| struct T3 { |
| f0: array<array<array<vec4h, 1>, 8>, 1>, |
| @align(64) @size(256) f1: array<array<array<array<array<f32, 1>, 6>, 1>, 10>, 1>, |
| @size(128) f2: vec4h, |
| @align(16) @size(320) f3: array<T2, 2>, |
| @size(1472) f4: array<array<vec2u, 10>, 5>, |
| } |
| |
| struct FragmentInput11 { |
| @builtin(front_facing) front_facing: bool, |
| } |
| |
| @group(0) @binding(308) var st15: texture_storage_1d<r32sint, read_write>; |
| |
| struct FragmentInput12 { |
| @location(4) location_4: vec4i, |
| @location(14) @interpolate(flat, centroid) location_14: vec2i, |
| @location(8) location_8: f32, |
| @location(2) location_2: vec2u, |
| } |
| |
| struct FragmentInput13 { |
| @builtin(sample_mask) sample_mask: u32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(59) var<storage, read_write> buffer53: array<array<f16, 176>>; |
| |
| struct FragmentInput9 { |
| @location(8) location_8: f32, |
| } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| struct ComputeInput4 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @group(0) @binding(116) var tex6: texture_cube_array<f32>; |
| |
| struct FragmentInput8 { |
| @location(4) location_4: vec4i, |
| @location(3) @interpolate(flat, centroid) location_3: vec2h, |
| } |
| |
| @group(0) @binding(3) var st12: texture_storage_3d<rgba16float, write>; |
| |
| /* used global variables: buffer50, buffer51, st12, st15 */ |
| @fragment |
| fn fragment4(@location(2) location_2: vec2u, @location(14) @interpolate(flat) location_14: vec2i, @builtin(sample_index) sample_index: u32, a3: FragmentInput8, a4: FragmentInput9) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| for (var jj72=0u; jj72<130; jj72++) { for (var jj19=0u; jj19<4; jj19++) { buffer51[unconst_u32(45336907)][unconst_u32(860437573)][jj72][unconst_u32(101209827)][jj19][u32(buffer51[arrayLength(&buffer51)][1][unconst_u32(428891357)][2][u32((*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(421071725)][unconst_u32(897875593)][unconst_u32(235046227)][1][0])][unconst_u32(130064747)])] = buffer51[arrayLength(&buffer51)][unconst_u32(1003740324)][127][unconst_u32(605618734)][1][0]; } } |
| let ptr23: ptr<storage, f16, read_write> = &(*&buffer51)[unconst_u32(1540348275)][unconst_u32(1363261559)][127][unconst_u32(109743257)][1][unconst_u32(2700915281)]; |
| let ptr24: ptr<storage, array<f16, 1>, read_write> = &(*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(385056311)][unconst_u32(563269529)][2][unconst_u32(42642820)]; |
| textureStore(st15, unconst_i32(22214560), vec4i(vec4i(unconst_i32(203595893), unconst_i32(6610038), unconst_i32(-116491723), unconst_i32(-85015356)))); |
| out.location_1 = i32(buffer51[arrayLength(&buffer51)][1][127][2][unconst_u32(881749435)][unconst_u32(475570900)]); |
| textureStore(st12, vec3i(unconst_i32(699173839), unconst_i32(783446579), unconst_i32(649110281)), vec4f(vec4f(unconst_f32(0.1931), unconst_f32(0.06196e16), unconst_f32(0.2452e29), unconst_f32(0.2810e-41)))); |
| for (var ii27=0u; ii27<0x1000; ii27+=0x11) { buffer50[ii27][unconst_u32(954515451)] &= vec2i(i32((*&buffer51)[unconst_u32(1226251063)][1][127][2][1][0])); } |
| let ptr25: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][u32((*&buffer51)[unconst_u32(612442297)][1][unconst_u32(1433820747)][2][unconst_u32(57487338)][0])][unconst_u32(252122016)][unconst_u32(93818253)][1][0]; |
| buffer51[unconst_u32(674166875)][1][unconst_u32(371667292)][unconst_u32(831021898)][unconst_u32(2267837389)][unconst_u32(374367659)] = (*&buffer51)[unconst_u32(889810558)][1][unconst_u32(99094864)][unconst_u32(447606000)][1][0]; |
| out.location_1 = i32(buffer51[arrayLength(&buffer51)][1][127][unconst_u32(1180654935)][1][0]); |
| out.location_1 = i32((*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(495886588)][unconst_u32(441273393)][unconst_u32(1379151462)][unconst_u32(437400437)][unconst_u32(176427368)]); |
| return out; |
| _ = buffer51; |
| _ = st12; |
| _ = buffer50; |
| _ = st15; |
| } |
| |
| /* used global variables: buffer51, st12 */ |
| @fragment |
| fn fragment5(@builtin(sample_mask) sample_mask: u32, a1: FragmentInput10, @builtin(sample_index) sample_index: u32) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| let ptr26: ptr<storage, f16, read_write> = &(*&buffer51)[unconst_u32(208859165)][unconst_u32(533603716)][unconst_u32(1368698587)][unconst_u32(585099342)][unconst_u32(585617861)][0]; |
| let ptr27: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][unconst_u32(316980237)][unconst_u32(2192442421)][u32((*&buffer51)[unconst_u32(547492709)][unconst_u32(1375060656)][127][2][1][0])][unconst_u32(1277855236)][0]; |
| let ptr28: ptr<storage, f16, read_write> = &buffer51[unconst_u32(658822933)][u32((*&buffer51)[arrayLength(&(*&buffer51))][1][u32((*&buffer51)[arrayLength(&(*&buffer51))][u32(buffer51[unconst_u32(3969352897)][1][127][2][1][0])][unconst_u32(319578502)][2][1][0])][2][unconst_u32(656946519)][0])][unconst_u32(618140777)][2][1][0]; |
| textureStore(st12, vec3i(unconst_i32(302162057), unconst_i32(441561426), unconst_i32(287313451)), vec4f(vec4f(unconst_f32(0.08770), unconst_f32(0.1289), unconst_f32(0.05484), unconst_f32(0.1099)))); |
| return out; |
| _ = st12; |
| _ = buffer51; |
| } |
| |
| /* used global variables: buffer50, buffer51 */ |
| @fragment |
| fn fragment6(a0: FragmentInput11, @location(3) location_3: vec2h, a2: FragmentInput12, a3: FragmentInput13, @builtin(position) position: vec4f, @builtin(sample_index) sample_index: u32) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| let ptr29: ptr<storage, array<array<f16, 1>, 2>, read_write> = &buffer51[unconst_u32(48349769)][1][unconst_u32(161389384)][2]; |
| { |
| let ptr30: ptr<storage, f16, read_write> = &buffer51[u32(buffer51[arrayLength(&buffer51)][1][127][unconst_u32(387508500)][1][0])][unconst_u32(1289396704)][unconst_u32(954785908)][u32((*&buffer51)[unconst_u32(424594703)][unconst_u32(301429971)][127][2][1][0])][unconst_u32(600748858)][0]; |
| if bool((*&buffer51)[arrayLength(&(*&buffer51))][unconst_u32(2086096870)][127][2][1][0]) { |
| loop { |
| let ptr31: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][1][unconst_u32(356335400)][unconst_u32(351566929)][unconst_u32(226052451)][0]; |
| let vf32: u32 = a2.location_2[unconst_u32(1225725947)]; |
| break; |
| _ = buffer51; |
| } |
| { |
| out.location_6 = vec2i(i32((*&buffer51)[unconst_u32(1031412164)][1][127][2][1][unconst_u32(2075002093)])); |
| out.location_0 -= vec4u(u32(buffer51[arrayLength(&buffer51)][unconst_u32(93234943)][127][unconst_u32(518116208)][unconst_u32(2456236552)][0])); |
| let ptr32: ptr<function, FragmentOutput4> = &out; |
| _ = buffer51; |
| } |
| while bool((*&buffer51)[unconst_u32(260445915)][unconst_u32(85213171)][127][unconst_u32(2061611662)][u32(buffer51[unconst_u32(436940515)][1][unconst_u32(68660233)][unconst_u32(327860398)][unconst_u32(18667649)][0])][0]) { |
| out.location_6 = vec2i(i32(buffer51[arrayLength(&buffer51)][unconst_u32(31100782)][127][2][unconst_u32(1716615624)][unconst_u32(737450572)])); |
| out.location_0 = vec4u(u32((*&buffer50)[arrayLength(&(*&buffer50))][20][unconst_u32(1723804513)])); |
| let ptr33: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][unconst_u32(503044121)][127][2][unconst_u32(1678238141)][0]; |
| _ = buffer51; |
| _ = buffer50; |
| } |
| let ptr34: ptr<storage, array<array<array<array<f16, 1>, 2>, 3>, 128>, read_write> = &(*&buffer51)[arrayLength(&(*&buffer51))][1]; |
| _ = buffer50; |
| _ = buffer51; |
| } |
| let ptr35: ptr<storage, f16, read_write> = &buffer51[arrayLength(&buffer51)][1][127][2][1][unconst_u32(138987392)]; |
| let ptr36: ptr<storage, f16, read_write> = &buffer51[unconst_u32(288961718)][u32((*&buffer51)[arrayLength(&(*&buffer51))][1][unconst_u32(1092263051)][2][1][0])][127][2][unconst_u32(1117272955)][u32((*&buffer51)[unconst_u32(151768537)][unconst_u32(1004496934)][unconst_u32(591056052)][2][unconst_u32(180625937)][0])]; |
| _ = buffer50; |
| _ = buffer51; |
| } |
| let ptr37: ptr<storage, array<array<array<f16, 1>, 2>, 3>, read_write> = &buffer51[arrayLength(&buffer51)][1][unconst_u32(325587972)]; |
| let ptr38: ptr<storage, array<f16, 1>, read_write> = &buffer51[arrayLength(&buffer51)][1][127][2][1]; |
| let ptr39: ptr<storage, array<f16, 1>, read_write> = &(*&buffer51)[unconst_u32(444538825)][unconst_u32(1070075072)][127][2][1]; |
| buffer50[unconst_u32(1008672232)][unconst_u32(1272784644)] |= vec2i(i32((*&buffer51)[unconst_u32(1982931254)][unconst_u32(197349751)][unconst_u32(121652139)][2][1][unconst_u32(273183968)])); |
| let ptr40: ptr<storage, array<array<array<f16, 1>, 2>, 3>, read_write> = &buffer51[u32(buffer51[unconst_u32(10956809)][unconst_u32(704433095)][127][2][1][unconst_u32(380286937)])][1][127]; |
| return out; |
| _ = buffer50; |
| _ = buffer51; |
| } |
| |
| /* used global variables: buffer50, buffer52, buffer53, buffer54, st15, tex6 */ |
| @compute @workgroup_size(3, 1, 1) |
| fn compute4(a0: ComputeInput4, @builtin(local_invocation_index) local_invocation_index: u32, @builtin(local_invocation_id) local_invocation_id: vec3u, @builtin(global_invocation_id) global_invocation_id: vec3u) { |
| buffer50[unconst_u32(230622637)][unconst_u32(1436019643)] -= (*&buffer54)[25][0].location_4.zw; |
| buffer52 |= (*&buffer50)[arrayLength(&(*&buffer50))][20].gggr; |
| while bool(buffer53[unconst_u32(354081754)][unconst_u32(525388082)]) { |
| buffer54[unconst_u32(38180289)][unconst_u32(7076139)] = FragmentInput8(vec4i(bitcast<i32>(max(unconst_f32(0.03531e-34), unconst_f32(0.06818e-2)))), bitcast<vec2h>(max(unconst_f32(0.03531e-34), unconst_f32(0.06818e-2)))); |
| textureStore(st15, unconst_i32(373823305), vec4i(vec4i(i32(textureNumLevels(tex6))))); |
| break; |
| _ = st15; |
| _ = buffer54; |
| _ = tex6; |
| } |
| _ = buffer50; |
| _ = st15; |
| _ = buffer54; |
| _ = tex6; |
| _ = buffer53; |
| _ = buffer52; |
| }`, |
| }); |
| let buffer55 = device0.createBuffer({size: 96, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let sampler9 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.02, |
| maxAnisotropy: 8, |
| }); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder10.setVertexBuffer(0, buffer3, 2_392); |
| } catch {} |
| document.body.prepend(canvas1); |
| await gc(); |
| let bindGroup40 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer56 = device0.createBuffer({size: 436, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false}); |
| let commandEncoder50 = device0.createCommandEncoder({label: ''}); |
| let computePassEncoder20 = commandEncoder46.beginComputePass(); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer26); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'srgb'}); |
| } catch {} |
| let textureView83 = texture58.createView({baseArrayLayer: 0}); |
| let renderPassEncoder6 = commandEncoder45.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: -32.52, g: 706.2, b: 929.0, a: -232.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 552004775, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(266), 14, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(0, buffer38, 0); |
| } catch {} |
| try { |
| commandEncoder30.copyBufferToBuffer(buffer32, 92, buffer29, 36, 36); |
| } catch {} |
| try { |
| renderPassEncoder5.insertDebugMarker('\u3baa'); |
| } catch {} |
| document.body.append(canvas1); |
| let videoFrame7 = new VideoFrame(videoFrame6, {timestamp: 0}); |
| let buffer57 = device0.createBuffer({size: 169, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let renderPassEncoder7 = commandEncoder33.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: -278.1, g: -366.2, b: 283.9, a: -596.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup21, new Uint32Array(950), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup30, new Uint32Array(1820), 96, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setStencilReference(1141); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToTexture({ |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 2, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 38, resource: textureView35}, |
| {binding: 0, resource: {buffer: buffer34, offset: 0}}, |
| {binding: 2, resource: textureView31}, |
| ], |
| }); |
| let texture65 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView84 = texture45.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup40, new Uint32Array(242), 59, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer24, 'uint16', 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| computePassEncoder18.insertDebugMarker('\u{1fedf}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new DataView(new Uint8Array(13710).map((_, i) => i).buffer), 1026, 16); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture66 = device0.createTexture({ |
| size: [828, 1, 7], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView85 = texture55.createView({format: 'bgra8unorm-srgb', baseMipLevel: 0}); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup28); |
| } catch {} |
| let textureView86 = texture7.createView({dimension: '2d', aspect: 'all'}); |
| let renderPassEncoder8 = commandEncoder20.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: -593.4, g: 279.4, b: -285.2, a: -917.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 279835565, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup13, new Uint32Array(363), 363, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(1, bindGroup38, new Uint32Array(722), 113, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.draw(132, 0, 2_450_939_040); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline6); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 4, resource: {buffer: buffer15, offset: 512}}, |
| {binding: 312, resource: sampler0}, |
| {binding: 153, resource: {buffer: buffer46}}, |
| {binding: 1, resource: {buffer: buffer27}}, |
| {binding: 109, resource: textureView26}, |
| {binding: 2, resource: externalTexture5}, |
| {binding: 524, resource: textureView85}, |
| {binding: 49, resource: {buffer: buffer34}}, |
| {binding: 5, resource: externalTexture2}, |
| {binding: 59, resource: {buffer: buffer46}}, |
| {binding: 0, resource: textureView32}, |
| {binding: 308, resource: textureView55}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 116, resource: textureView4}, |
| {binding: 61, resource: textureView9}, |
| {binding: 159, resource: sampler1}, |
| {binding: 17, resource: externalTexture3}, |
| {binding: 7, resource: {buffer: buffer46}}, |
| {binding: 3, resource: textureView42}, |
| ], |
| }); |
| let buffer58 = device0.createBuffer({ |
| size: 219, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup6, new Uint32Array(815), 43, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer57, 'uint16', 2, 16); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(0, buffer26, 0, 35); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| let sampler10 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', maxAnisotropy: 1}); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer35, 'uint32', 36, 31); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer6, 'uint16', 8, 31); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 0, new Float32Array(34690).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.2146)), 4484, 0); |
| } catch {} |
| try { |
| externalTexture2.label = '\u0eee\u924a\u0585\u{1f634}\u71ff'; |
| } catch {} |
| let commandEncoder51 = device0.createCommandEncoder({label: ''}); |
| let texture67 = device0.createTexture({ |
| size: [2, 2, 1], |
| sampleCount: 1, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder19.setBindGroup(3, bindGroup40); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 7, resource: {buffer: buffer46, offset: 2304}}, |
| {binding: 59, resource: {buffer: buffer46, size: 1512}}, |
| {binding: 17, resource: externalTexture8}, |
| {binding: 1, resource: {buffer: buffer22, size: 72}}, |
| {binding: 159, resource: sampler10}, |
| {binding: 49, resource: {buffer: buffer25, size: 16}}, |
| {binding: 524, resource: textureView80}, |
| {binding: 308, resource: textureView16}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 2, resource: externalTexture0}, |
| {binding: 0, resource: textureView32}, |
| {binding: 5, resource: externalTexture5}, |
| {binding: 116, resource: textureView4}, |
| {binding: 109, resource: textureView11}, |
| {binding: 312, resource: sampler2}, |
| {binding: 61, resource: textureView9}, |
| {binding: 4, resource: {buffer: buffer15, offset: 768}}, |
| {binding: 3, resource: textureView57}, |
| ], |
| }); |
| let texture68 = device0.createTexture({ |
| size: [207], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer0, 32); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| renderPassEncoder5.pushDebugGroup('\u0b8c'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture35, |
| mipLevel: 0, |
| origin: {x: 99, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(20).fill(198), /* required buffer size: 20 */ |
| {offset: 20}, {width: 15, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout7 = pipeline3.getBindGroupLayout(0); |
| let commandEncoder52 = device0.createCommandEncoder(); |
| let texture69 = device0.createTexture({ |
| size: [207], |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture70 = device0.createTexture({ |
| size: [8, 8, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer32, 68); |
| } catch {} |
| try { |
| textureView15.label = ''; |
| } catch {} |
| let recycledExplicitBindGroupLayout8 = pipeline3.getBindGroupLayout(0); |
| let buffer59 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC}); |
| let textureView87 = texture69.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder5.popDebugGroup(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 16, resource: {buffer: buffer4}}, |
| {binding: 65, resource: externalTexture8}, |
| {binding: 4, resource: textureView45}, |
| ], |
| }); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer25, 32, 9); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: imageData5, |
| origin: { x: 16, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 22, y: 13, z: 79}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 15, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup33); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup19, new Uint32Array(9), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup38, new Uint32Array(2166), 402, 0); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let autogeneratedBindGroupLayout2 = pipeline9.getBindGroupLayout(0); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let textureView88 = texture40.createView({baseArrayLayer: 21, arrayLayerCount: 81}); |
| let renderPassEncoder9 = commandEncoder55.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView19, |
| clearValue: { r: -14.55, g: -305.6, b: -261.9, a: -122.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup37, new Uint32Array(1853), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup15, new Uint32Array(130), 6, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer58, 76); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer57, 'uint16', 8, 7); |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'iec61966-2-1'} }); |
| let buffer60 = device0.createBuffer({size: 108, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let texture71 = device0.createTexture({ |
| size: [345], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture72 = device0.createTexture({ |
| size: [207, 1, 50], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer55, 'uint16', 8, 3); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer36, 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup40); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 116, new DataView(new ArrayBuffer(44838)), 18, 0); |
| } catch {} |
| let pipeline11 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x500faba4}, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment4', |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| buffers: [ |
| { |
| arrayStride: 36, |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 3}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 2}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 1}, |
| {format: 'float32x3', offset: 0, shaderLocation: 8}, |
| {format: 'uint32', offset: 8, shaderLocation: 11}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 5}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 0}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 13}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint8x4', offset: 4, shaderLocation: 15}, |
| {format: 'float32x2', offset: 0, shaderLocation: 14}, |
| {format: 'unorm8x2', offset: 0, shaderLocation: 7}, |
| {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 6}, |
| ], |
| }, |
| {arrayStride: 52, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x2', offset: 1136, shaderLocation: 12}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: false, |
| }, |
| }); |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder6.draw(303, 0, 1_116_468_984); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer36, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 27, y: 40 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 76, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture73 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 390}, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder8.setVertexBuffer(7, buffer25, 0, 25); |
| } catch {} |
| try { |
| renderBundleEncoder6.draw(31, 0, 31_932_516); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer19, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| await gc(); |
| try { |
| globalThis.someLabel = commandEncoder36.label; |
| } catch {} |
| let texture74 = device0.createTexture({ |
| size: {width: 414}, |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture75 = device0.createTexture({ |
| size: {width: 345}, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView89 = texture35.createView({dimension: '2d', baseArrayLayer: 1}); |
| let computePassEncoder21 = commandEncoder42.beginComputePass(); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup13, new Uint32Array(2065), 60, 0); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer24, 'uint32', 52, 3); |
| } catch {} |
| try { |
| renderBundleEncoder6.draw(147, 0, 432_977_133, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer36, 0); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 656 */ |
| offset: 656, |
| bytesPerRow: 29696, |
| buffer: buffer32, |
| }, { |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 120, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 7, resource: textureView46}, |
| {binding: 16, resource: textureView17}, |
| {binding: 3, resource: {buffer: buffer46}}, |
| {binding: 1, resource: textureView44}, |
| {binding: 2, resource: {buffer: buffer7, offset: 0, size: 28}}, |
| ], |
| }); |
| let texture76 = device0.createTexture({ |
| label: '\u4162\u{1f716}\u0f7a\u0faf', |
| size: {width: 1380, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup5, new Uint32Array(4782), 1_622, 0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder52.copyTextureToTexture({ |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 73, y: 0, z: 39}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| bindGroup16.label = '\u0071\ue7a2\u0946'; |
| } catch {} |
| let bindGroup46 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer61 = device0.createBuffer({ |
| size: 180, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true, |
| }); |
| let texture77 = device0.createTexture({ |
| size: [345, 1, 41], |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView90 = texture7.createView({aspect: 'all', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup19, new Uint32Array(339), 35, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup36, new Uint32Array(697), 62, 0); |
| } catch {} |
| let texture78 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame3, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup3, new Uint32Array(264), 82, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'}); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} }); |
| let textureView91 = texture76.createView({label: '\u05f9\u6d28\u0e62\u0689', format: 'rg32uint', arrayLayerCount: 1}); |
| let textureView92 = texture8.createView({}); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup28, new Uint32Array(3444), 557, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer55, 'uint32', 0, 1); |
| } catch {} |
| try { |
| commandEncoder29.copyBufferToTexture({ |
| /* bytesInLastRow: 1432 widthInBlocks: 358 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 160 */ |
| offset: 160, |
| bytesPerRow: 18176, |
| buffer: buffer56, |
| }, { |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 91, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 358, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let textureView93 = texture73.createView({mipLevelCount: 1}); |
| let textureView94 = texture29.createView({}); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup46, new Uint32Array(319), 90, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup41, new Uint32Array(168), 5, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.draw(44, 0, 589_580_708, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer26, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer60, 'uint16', 2, 24); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer30, 84, new Float32Array(17106).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.9915)), 39, 0); |
| } catch {} |
| let bindGroup47 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer62 = device0.createBuffer({size: 144, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer58, 0); |
| } catch {} |
| let textureView95 = texture73.createView({format: 'r32float'}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer36, 'uint32', 8, 7); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder6.draw(44, 0, 372_212_962); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer23, 104); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(1, buffer6); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas1); |
| let buffer63 = device0.createBuffer({size: 72, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let textureView96 = texture30.createView({dimension: '3d', mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup28, new Uint32Array(3417), 535, 0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup37, new Uint32Array(642), 228, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer45, 'uint32', 8, 14); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndirect(buffer23, 44); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer4, 'uint16', 0, 1); |
| } catch {} |
| try { |
| commandEncoder30.copyBufferToTexture({ |
| /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 40 */ |
| offset: 40, |
| bytesPerRow: 256, |
| buffer: buffer42, |
| }, { |
| texture: texture75, |
| mipLevel: 0, |
| origin: {x: 46, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToTexture({ |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 113, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 18}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 6}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 28, new DataView(new ArrayBuffer(48044)), 432, 4); |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 0, resource: textureView22}, |
| {binding: 5, resource: externalTexture10}, |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 312, resource: sampler2}, |
| {binding: 1, resource: {buffer: buffer58, size: 78}}, |
| {binding: 17, resource: externalTexture1}, |
| {binding: 4, resource: {buffer: buffer46}}, |
| {binding: 7, resource: {buffer: buffer15, size: 596}}, |
| {binding: 308, resource: textureView55}, |
| {binding: 59, resource: {buffer: buffer22, offset: 0, size: 352}}, |
| {binding: 3, resource: textureView41}, |
| {binding: 524, resource: textureView80}, |
| {binding: 61, resource: textureView9}, |
| {binding: 49, resource: {buffer: buffer7}}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 116, resource: textureView2}, |
| {binding: 159, resource: sampler3}, |
| {binding: 109, resource: textureView23}, |
| {binding: 2, resource: externalTexture9}, |
| ], |
| }); |
| let commandEncoder60 = device0.createCommandEncoder(); |
| let textureView97 = texture11.createView({}); |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer38, 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(0, bindGroup36, new Uint32Array(368), 36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.drawIndexedIndirect(buffer19, 36); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer0, 200); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer21, 36, buffer47, 0, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 72, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 53, y: 29, z: 52}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup35, new Uint32Array(4065), 600, 0); |
| } catch {} |
| try { |
| commandEncoder53.insertDebugMarker('\u8a14'); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'unspecified'} }); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let texture79 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer0, 24); }; |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer45, 'uint16', 48, 18); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup40); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer62, 'uint16', 14, 74); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer58, 0); |
| } catch {} |
| try { |
| commandEncoder34.copyTextureToTexture({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture33, |
| mipLevel: 0, |
| origin: {x: 187, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(9).fill(183), /* required buffer size: 9 */ |
| {offset: 9, bytesPerRow: 4003}, {width: 996, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'unspecified', transfer: 'smpteSt4281'} }); |
| let bindGroup49 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 239, resource: {buffer: buffer58, size: 93}}, |
| {binding: 2, resource: textureView45}, |
| {binding: 25, resource: {buffer: buffer25, size: 40}}, |
| ], |
| }); |
| let renderBundle1 = renderBundleEncoder6.finish({}); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup48, new Uint32Array(6565), 422, 2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| buffer21.unmap(); |
| } catch {} |
| try { |
| renderBundleEncoder15.insertDebugMarker('\u1711'); |
| } catch {} |
| let textureView98 = texture78.createView({format: 'rg32uint'}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer1, 20); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer6, 'uint32', 4, 8); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer26, 0, 21); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder5.drawIndirect(buffer22, 36); |
| } catch {} |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', minBindingSize: 10, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 73, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 154, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let renderBundle2 = renderBundleEncoder5.finish({}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer19, 4); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer45); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup45, new Uint32Array(670), 156, 0); |
| } catch {} |
| try { |
| await buffer31.mapAsync(GPUMapMode.WRITE, 0, 4); |
| } catch {} |
| canvas1.height = 478; |
| await gc(); |
| let bindGroup50 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer64 = device0.createBuffer({size: 68, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let renderPassEncoder10 = commandEncoder27.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: 877.4, g: -411.4, b: 346.5, a: -858.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer35, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline10); |
| } catch {} |
| let pipeline12 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule2, constants: {}}}); |
| let offscreenCanvas0 = new OffscreenCanvas(183, 403); |
| let imageData6 = new ImageData(36, 28); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let texture80 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 83}, |
| sampleCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer60, 16); }; |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| let autogeneratedBindGroupLayout3 = pipeline8.getBindGroupLayout(1); |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer19, 12); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer62, 'uint32', 28, 40); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup38, new Uint32Array(838), 94, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline11); |
| } catch {} |
| let buffer65 = device0.createBuffer({size: 120, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let textureView99 = texture9.createView({}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup48, new Uint32Array(1692), 380, 2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer32, 132); }; |
| } catch {} |
| try { |
| renderBundleEncoder4.drawIndirect(buffer19, 0); |
| } catch {} |
| let pipeline13 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5}}); |
| let pipeline14 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x2', offset: 240, shaderLocation: 10}, |
| {format: 'float16x4', offset: 1064, shaderLocation: 4}, |
| {format: 'float32x4', offset: 1368, shaderLocation: 6}, |
| {format: 'snorm16x2', offset: 868, shaderLocation: 1}, |
| {format: 'float32x3', offset: 124, shaderLocation: 14}, |
| {format: 'float32x4', offset: 200, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 656, shaderLocation: 0}, |
| {format: 'uint32x3', offset: 476, shaderLocation: 2}, |
| {format: 'uint32x3', offset: 292, shaderLocation: 7}, |
| {format: 'snorm16x4', offset: 328, shaderLocation: 12}, |
| ], |
| }, |
| { |
| arrayStride: 16, |
| attributes: [ |
| {format: 'float32x3', offset: 0, shaderLocation: 5}, |
| {format: 'uint32x4', offset: 0, shaderLocation: 11}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 13}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'ccw'}, |
| }); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let computePassEncoder22 = commandEncoder29.beginComputePass(); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer57, 'uint32', 16, 21); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let computePassEncoder23 = commandEncoder41.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer23, 8); }; |
| } catch {} |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer45, 'uint16', 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup29); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer36, 'uint32', 4, 5); |
| } catch {} |
| document.body.append(canvas0); |
| let buffer66 = device0.createBuffer({size: 16, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let texture81 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 2}, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer60, 'uint32', 0, 12); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup38, new Uint32Array(1474), 141, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(3, buffer6, 12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 2_596, new Float32Array(21289).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.412)), 9034, 168); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| struct VertexInput18 { |
| @location(2) @interpolate(linear, either) location_2: f32, |
| } |
| |
| @group(0) @binding(153) var<storage, read_write> buffer73: array<vec4u, 52>; |
| |
| @group(0) @binding(1) var<uniform> buffer67: array<array<array<array<array<array<array<vec4u, 3>, 1>, 1>, 1>, 1>, 1>, 1>; |
| |
| struct T0 { |
| @size(180) f0: vec2u, |
| } |
| |
| @group(0) @binding(524) var tex9: texture_2d<f32>; |
| |
| var<workgroup> vw21: vec2i; |
| |
| struct FragmentOutput5 { |
| @location(0) location_0: vec4u, |
| @builtin(sample_mask) sample_mask: u32, |
| @location(7) location_7: vec4u, |
| @location(1) location_1: vec2i, |
| } |
| |
| struct VertexInput19 { |
| @location(4) location_4: vec4i, |
| } |
| |
| struct ComputeInput6 { |
| @builtin(local_invocation_index) local_invocation_index: u32, |
| } |
| |
| @group(0) @binding(308) var st18: texture_storage_1d<r32sint, read_write>; |
| |
| @group(0) @binding(61) var st17: texture_storage_2d_array<r32uint, read_write>; |
| |
| struct ComputeInput7 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| struct ComputeInput5 { |
| @builtin(workgroup_id) workgroup_id: vec3u, |
| } |
| |
| struct VertexOutput3 { |
| @location(5) @interpolate(flat, either) location_5: f32, |
| @location(10) @interpolate(flat, first) location_10: vec4u, |
| @location(14) location_14: vec2i, |
| @location(2) @interpolate(flat, sample) location_2: vec2i, |
| @location(7) location_7: u32, |
| @location(6) location_6: i32, |
| @location(8) location_8: vec2u, |
| @location(9) @interpolate(perspective, centroid) location_9: vec4h, |
| @location(1) @interpolate(perspective, center) location_1: vec4f, |
| @location(12) @interpolate(flat, centroid) location_12: u32, |
| @location(0) location_0: i32, |
| @location(3) location_3: vec2f, |
| @location(11) location_11: vec4i, |
| @builtin(position) position: vec4f, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| var<workgroup> vw20: vec2u; |
| |
| struct VertexInput16 { |
| @location(15) @interpolate(flat, first) location_15: vec4i, |
| @location(1) @interpolate(perspective) location_1: f16, |
| @location(6) @interpolate(flat) location_6: vec2i, |
| @builtin(vertex_index) vertex_index: u32, |
| @location(13) location_13: vec2u, |
| @location(8) @interpolate(flat) location_8: vec4u, |
| @location(5) @interpolate(perspective) location_5: vec4h, |
| @location(11) location_11: vec4u, |
| @location(3) @interpolate(flat) location_3: vec2i, |
| @location(12) location_12: u32, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(10) var<storage, read_write> buffer70: array<array<array<ComputeInput5, 64>, 3>>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(49) var<storage, read_write> buffer71: array<i32, 4>; |
| |
| struct VertexInput17 { |
| @location(7) @interpolate(linear, either) location_7: vec2f, |
| @location(0) @interpolate(flat, first) location_0: vec2i, |
| @builtin(instance_index) instance_index: u32, |
| @location(9) @interpolate(perspective) location_9: vec4h, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: buffer67 */ |
| @vertex |
| fn vertex4(a0: VertexInput16, a1: VertexInput17, @location(10) @interpolate(flat) location_10: i32, a3: VertexInput18, a4: VertexInput19) -> VertexOutput3 { |
| var out: VertexOutput3; |
| out.location_0 = i32(buffer67[0][0][unconst_u32(738516004)][unconst_u32(220648969)][0][0][2][unconst_u32(924000259)]); |
| return out; |
| _ = buffer67; |
| } |
| |
| /* used global variables: buffer67, buffer70, st18, tex9 */ |
| @fragment |
| fn fragment7(@location(8) location_8: vec4f, @location(2) location_2: vec2f) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| let ptr41: ptr<uniform, vec4u> = &buffer67[0][0][unconst_u32(2487781333)][0][0][0][2]; |
| let ptr42: ptr<uniform, array<array<vec4u, 3>, 1>> = &(*&buffer67)[0][0][0][0][0]; |
| let ptr43: ptr<storage, array<array<ComputeInput5, 64>, 3>, read_write> = &(*&buffer70)[arrayLength(&(*&buffer70))]; |
| let ptr44: ptr<uniform, vec4u> = &buffer67[0][unconst_u32(1700209304)][unconst_u32(417583541)][unconst_u32(455890372)][unconst_u32(388290386)][0][2]; |
| let vf33: vec2u = textureDimensions(tex9, unconst_i32(129218515)); |
| let ptr45: ptr<uniform, array<array<vec4u, 3>, 1>> = &buffer67[unconst_u32(291769389)][0][0][unconst_u32(1543908004)][0]; |
| textureStore(st18, unconst_i32(-1107954345), vec4i(vec4i(unconst_i32(-121364319), unconst_i32(223672229), unconst_i32(159552115), unconst_i32(36806828)))); |
| return out; |
| _ = st18; |
| _ = buffer70; |
| _ = tex9; |
| _ = buffer67; |
| } |
| |
| /* used global variables: buffer67, buffer71, buffer73, st17 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute5(a0: ComputeInput5, a1: ComputeInput6, a2: ComputeInput7) { |
| buffer73[unconst_u32(470904277)] &= vec4u((*&buffer67)[unconst_u32(463699463)][unconst_u32(1235520433)][unconst_u32(624851088)][unconst_u32(1241118585)][unconst_u32(125896168)][0][2][unconst_u32(1464469223)]); |
| buffer71[3] = bitcast<i32>(pack4xU8Clamp((*&buffer67)[0][unconst_u32(826500177)][0][unconst_u32(207834527)][0][0][2])); |
| textureStore(st17, vec2i(unconst_i32(290786300), unconst_i32(-96729857)), unconst_i32(264775090), vec4u(vec4u(unconst_u32(90969319), unconst_u32(60185880), unconst_u32(1452251545), unconst_u32(649811044)))); |
| let ptr46: ptr<uniform, array<array<vec4u, 3>, 1>> = &(*&buffer67)[0][0][0][0][unconst_u32(30426296)]; |
| _ = st17; |
| _ = buffer67; |
| _ = buffer71; |
| _ = buffer73; |
| }`, |
| }); |
| let texture82 = device0.createTexture({ |
| size: {width: 828}, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup48, new Uint32Array(768), 128, 2); |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer38, 'uint16', 14, 3); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| texture49.destroy(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 124, new DataView(new ArrayBuffer(82000)), 1349, 12); |
| } catch {} |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let texture83 = device0.createTexture({ |
| size: [1380, 1, 14], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler11 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 97.63, |
| }); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroupsIndirect(buffer23, 4); }; |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder37.copyBufferToBuffer(buffer33, 36, buffer7, 8, 8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 16, new DataView(new ArrayBuffer(23052)), 776, 16); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(171).fill(94), /* required buffer size: 171 */ |
| {offset: 171}, {width: 49, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let commandBuffer6 = commandEncoder46.finish(); |
| let renderBundle3 = renderBundleEncoder4.finish({}); |
| try { |
| renderBundleEncoder0.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u3b1c'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer45, 36, new Uint32Array(217).map((_, i) => i * 1), 0, 0); |
| } catch {} |
| let pipeline15 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x70290bb}, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment5', |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 60, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 4, shaderLocation: 10}, |
| {format: 'float32x2', offset: 0, shaderLocation: 9}, |
| {format: 'float32', offset: 20, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 28, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32x3', offset: 0, shaderLocation: 7}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front'}, |
| }); |
| let recycledExplicitBindGroupLayout9 = pipeline1.getBindGroupLayout(0); |
| let bindGroup51 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 312, resource: sampler0}, |
| {binding: 7, resource: {buffer: buffer22, size: 176}}, |
| {binding: 17, resource: externalTexture1}, |
| {binding: 3, resource: textureView57}, |
| {binding: 1, resource: {buffer: buffer58, size: 70}}, |
| {binding: 524, resource: textureView35}, |
| {binding: 109, resource: textureView99}, |
| {binding: 153, resource: {buffer: buffer15, size: 872}}, |
| {binding: 5, resource: externalTexture11}, |
| {binding: 308, resource: textureView51}, |
| {binding: 4, resource: {buffer: buffer15}}, |
| {binding: 49, resource: {buffer: buffer7}}, |
| {binding: 59, resource: {buffer: buffer46}}, |
| {binding: 10, resource: {buffer: buffer46, offset: 512}}, |
| {binding: 61, resource: textureView8}, |
| {binding: 116, resource: textureView4}, |
| {binding: 0, resource: textureView32}, |
| {binding: 159, resource: sampler10}, |
| {binding: 2, resource: externalTexture2}, |
| ], |
| }); |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer23, 12, 40); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(0, buffer3, 1_220, 382); |
| } catch {} |
| let img0 = await imageWithData(38, 23, '#10101010', '#20202020'); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let textureView100 = texture69.createView({mipLevelCount: 1}); |
| let textureView101 = texture34.createView({baseMipLevel: 1, mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder24 = commandEncoder65.beginComputePass(); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true}); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup48, new Uint32Array(1710), 220, 2); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup40, new Uint32Array(748), 78, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer6, 'uint32', 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(0, bindGroup36, new Uint32Array(576), 3, 0); |
| } catch {} |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let textureView102 = texture32.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 8}); |
| let renderPassEncoder11 = commandEncoder63.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: -133.8, g: 974.6, b: 167.1, a: -357.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup29, new Uint32Array(2020), 116, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer24, 'uint16', 20, 3); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer1, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let pipeline16 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x12200d03}, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment5', |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: 0}], |
| }, |
| vertex: { |
| module: shaderModule1, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 344, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm16x2', offset: 32, shaderLocation: 5}, |
| {format: 'unorm16x2', offset: 52, shaderLocation: 14}, |
| {format: 'snorm8x4', offset: 8, shaderLocation: 15}, |
| {format: 'sint8x2', offset: 82, shaderLocation: 10}, |
| {format: 'snorm16x2', offset: 64, shaderLocation: 1}, |
| {format: 'uint32x3', offset: 88, shaderLocation: 7}, |
| {format: 'sint16x4', offset: 28, shaderLocation: 8}, |
| {format: 'sint16x4', offset: 4, shaderLocation: 13}, |
| {format: 'uint8x4', offset: 4, shaderLocation: 2}, |
| {format: 'snorm8x2', offset: 40, shaderLocation: 0}, |
| {format: 'float32x3', offset: 4, shaderLocation: 9}, |
| {format: 'uint32x3', offset: 56, shaderLocation: 3}, |
| {format: 'uint32x3', offset: 92, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 76, shaderLocation: 6}, |
| {format: 'float16x2', offset: 308, shaderLocation: 4}, |
| ], |
| }, |
| { |
| arrayStride: 1324, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x3', offset: 60, shaderLocation: 12}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'back'}, |
| }); |
| let bindGroup52 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 159, resource: sampler4}, |
| {binding: 116, resource: textureView2}, |
| {binding: 59, resource: {buffer: buffer46, offset: 768}}, |
| {binding: 109, resource: textureView11}, |
| {binding: 4, resource: {buffer: buffer15}}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 61, resource: textureView90}, |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 49, resource: {buffer: buffer25, size: 28}}, |
| {binding: 0, resource: textureView22}, |
| {binding: 312, resource: sampler2}, |
| {binding: 7, resource: {buffer: buffer61}}, |
| {binding: 308, resource: textureView16}, |
| {binding: 1, resource: {buffer: buffer42, size: 49}}, |
| {binding: 17, resource: externalTexture5}, |
| {binding: 524, resource: textureView80}, |
| {binding: 5, resource: externalTexture5}, |
| {binding: 3, resource: textureView42}, |
| {binding: 2, resource: externalTexture10}, |
| ], |
| }); |
| let commandEncoder73 = device0.createCommandEncoder(); |
| let textureView103 = texture7.createView({dimension: '2d'}); |
| let textureView104 = texture22.createView({aspect: 'depth-only'}); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setScissorRect(45, 0, 132, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer4, 'uint16', 0, 2); |
| } catch {} |
| let arrayBuffer0 = buffer61.getMappedRange(0, 12); |
| let buffer74 = device0.createBuffer({ |
| size: 197, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture84 = device0.createTexture({ |
| size: {width: 1, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView105 = texture76.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder6.setVertexBuffer(4, buffer36, 0, 7); |
| } catch {} |
| try { |
| renderBundleEncoder0.draw(47, 0, 429_190_440); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let bindGroup53 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout2, |
| entries: [ |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 61, resource: textureView8}, |
| {binding: 7, resource: {buffer: buffer15}}, |
| {binding: 1, resource: {buffer: buffer28, size: 74}}, |
| ], |
| }); |
| let buffer75 = device0.createBuffer({size: 244, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let texture85 = device0.createTexture({ |
| size: [1380, 1, 3], |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderBundleEncoder0.draw(346, 0, 90_086_416); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline16); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 7} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture83, |
| mipLevel: 1, |
| origin: {x: 80, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(5, buffer65); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexed(1, 0, 0, 12_184_451); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndirect(buffer23, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture57, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(38).fill(150), /* required buffer size: 38 */ |
| {offset: 38}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 3} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 114, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let texture86 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup22, new Uint32Array(806), 63, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexed(1, 0, 0, 6_199_949); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({layout: veryExplicitBindGroupLayout2, entries: [{binding: 93, resource: textureView1}]}); |
| let texture87 = device0.createTexture({size: {width: 4}, dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer60, 'uint32', 0, 10); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer0, 108); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer62, 'uint16', 30, 42); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(6, buffer61); |
| } catch {} |
| try { |
| await buffer64.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| try { |
| commandEncoder32.copyTextureToTexture({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 43}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData7 = new ImageData(80, 4); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer35, 'uint16', 0, 15); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup38, new Uint32Array(1038), 102, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer1, 0); |
| } catch {} |
| try { |
| commandEncoder52.clearBuffer(buffer36); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer6]); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(videoFrame5); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup48, new Uint32Array(61), 3, 2); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexed(1, 0, 0, 654_820_979); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(4, buffer38); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 0, new DataView(new Uint8Array(39475).map((_, i) => i).buffer), 4316, 0); |
| } catch {} |
| let texture88 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler12 = device0.createSampler({addressModeV: 'mirror-repeat'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer19, 12); }; |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup20, new Uint32Array(224), 39, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer1, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer4, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer45, 16, 23); |
| } catch {} |
| let arrayBuffer1 = buffer31.getMappedRange(0, 0); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(94).fill(107), /* required buffer size: 94 */ |
| {offset: 94}, {width: 47, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| veryExplicitBindGroupLayout6.label = '\u{1f725}\u{1fb78}\ue64b\u0612\u{1fdda}\u0923\ube87'; |
| } catch {} |
| let textureView106 = texture54.createView({}); |
| try { |
| renderBundleEncoder0.draw(201, 0, 1_002_871_390); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToTexture({ |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 37, y: 27, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 8}); |
| } catch {} |
| try { |
| offscreenCanvas0.getContext('webgl2'); |
| } catch {} |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 14, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 117, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 242, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup55 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer76 = device0.createBuffer({size: 120, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup50, new Uint32Array(61), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder19.insertDebugMarker('\u{1f7e2}'); |
| } catch {} |
| let buffer77 = device0.createBuffer({size: 472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let commandBuffer7 = commandEncoder2.finish({}); |
| let textureView107 = texture13.createView({}); |
| let computePassEncoder25 = commandEncoder32.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer0, 20); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer35, 'uint32', 88, 3); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer23, 28); |
| } catch {} |
| let videoFrame12 = new VideoFrame(videoFrame9, {timestamp: 0}); |
| let bindGroup56 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 4, resource: textureView100}, |
| {binding: 0, resource: {buffer: buffer7}}, |
| {binding: 73, resource: {buffer: buffer46, offset: 256, size: 4204}}, |
| {binding: 154, resource: textureView86}, |
| ], |
| }); |
| let renderBundle4 = renderBundleEncoder13.finish({}); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer32, 32); }; |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| await buffer37.mapAsync(GPUMapMode.READ, 0, 0); |
| } catch {} |
| await gc(); |
| let videoFrame13 = videoFrame5.clone(); |
| let bindGroup57 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 154, resource: textureView86}, |
| {binding: 73, resource: {buffer: buffer46}}, |
| {binding: 4, resource: textureView100}, |
| {binding: 0, resource: {buffer: buffer55}}, |
| ], |
| }); |
| let buffer78 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture89 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 232}, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer62, 12, 1); |
| } catch {} |
| let arrayBuffer2 = buffer61.getMappedRange(16, 20); |
| try { |
| commandEncoder73.copyTextureToTexture({ |
| texture: texture18, |
| 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: 828, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| {binding: 12, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 48, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer79 = device0.createBuffer({size: 328, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let commandEncoder76 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer35, 'uint32', 64, 10); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt2020', transfer: 'iec61966-2-1'} }); |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let texture90 = device0.createTexture({ |
| size: {width: 1380, height: 1, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup50, new Uint32Array(3150), 388, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer32, 28); |
| } catch {} |
| let texture91 = device0.createTexture({ |
| size: {width: 828, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder23.end(); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer36, 'uint32', 0, 3); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(0, buffer36, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexed(1, 0, 0, 642_996_347); |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer38, 'uint32', 4, 3); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(1, buffer26, 8, 18); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToBuffer(buffer43, 20, buffer32, 16, 12); |
| } catch {} |
| let buffer80 = device0.createBuffer({size: 98, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let texture92 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture93 = device0.createTexture({ |
| size: {width: 345}, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer26, 0, 5); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup44); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline8); |
| } catch {} |
| let autogeneratedBindGroupLayout4 = pipeline8.getBindGroupLayout(1); |
| let commandBuffer8 = commandEncoder41.finish(); |
| let textureView108 = texture90.createView({}); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup33, new Uint32Array(3423), 496, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer80, 0); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline14); |
| } catch {} |
| let imageData8 = new ImageData(12, 108); |
| let buffer81 = device0.createBuffer({ |
| size: 632, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let texture94 = device0.createTexture({ |
| size: [345], |
| dimension: '1d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer55, 'uint16', 22, 2); |
| } catch {} |
| try { |
| renderBundleEncoder0.setBindGroup(1, bindGroup38); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| let textureView109 = texture94.createView({}); |
| let computePassEncoder26 = commandEncoder37.beginComputePass(); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup32); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(1, bindGroup29, new Uint32Array(1034), 47, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder19); computePassEncoder19.dispatchWorkgroups(1, 3, 1); }; |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup16, new Uint32Array(1803), 147, 0); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToTexture({ |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 84, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer82 = device0.createBuffer({size: 312, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let texture95 = device0.createTexture({ |
| size: [1656, 1, 21], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder26.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndexedIndirect(buffer32, 48); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer26, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 93, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let commandEncoder80 = device0.createCommandEncoder(); |
| let texture96 = device0.createTexture({ |
| size: [8, 8, 1], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture97 = device0.createTexture({ |
| size: [414, 1, 1], |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder0.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer22, 36); |
| } catch {} |
| try { |
| commandEncoder64.insertDebugMarker('\ufc0f'); |
| } catch {} |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'unspecified', transfer: 'smpte240m'} }); |
| let bindGroup58 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 4, resource: textureView17}, |
| {binding: 16, resource: {buffer: buffer22, size: 20}}, |
| {binding: 65, resource: externalTexture7}, |
| ], |
| }); |
| let commandBuffer9 = commandEncoder7.finish(); |
| let textureView110 = texture91.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder19.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup14, new Uint32Array(221), 3, 0); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(3, bindGroup30); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer1, 4); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 44, new Float32Array(6634).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.766)), 927, 4); |
| } catch {} |
| let buffer83 = device0.createBuffer({size: 52, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup50); |
| } catch {} |
| try { |
| renderBundleEncoder0.drawIndirect(buffer19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer66, 'uint16', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(6, buffer45, 0, 15); |
| } catch {} |
| let bindGroup59 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture98 = device0.createTexture({ |
| size: {width: 1380, height: 1, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder27 = commandEncoder61.beginComputePass(); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb']}); |
| let renderBundle5 = renderBundleEncoder0.finish({}); |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer80, 'uint32', 28, 24); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer66, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(4, buffer82, 0); |
| } catch {} |
| try { |
| await buffer83.mapAsync(GPUMapMode.WRITE, 8); |
| } catch {} |
| let recycledExplicitBindGroupLayout10 = pipeline1.getBindGroupLayout(0); |
| let buffer84 = device0.createBuffer({size: 192, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let texture99 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 1}, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float'], |
| }); |
| try { |
| renderBundleEncoder20.setVertexBuffer(2, buffer23); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer85 = device0.createBuffer({ |
| size: 36748, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 2435}); |
| let textureView111 = texture20.createView({baseMipLevel: 0, baseArrayLayer: 8, arrayLayerCount: 9}); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer36, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer35, 'uint16', 114, 20); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(3, buffer76, 12, 45); |
| } catch {} |
| let pipeline17 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 128, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 8, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 68, shaderLocation: 0}, |
| {format: 'float16x4', offset: 60, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 7}, |
| {format: 'sint16x4', offset: 12, shaderLocation: 4}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 9}, |
| {format: 'unorm8x4', offset: 0, shaderLocation: 5}, |
| {format: 'float32x4', offset: 0, shaderLocation: 8}, |
| {format: 'uint32x4', offset: 32, shaderLocation: 11}, |
| {format: 'uint32x4', offset: 56, shaderLocation: 1}, |
| {format: 'uint32x2', offset: 44, shaderLocation: 2}, |
| {format: 'uint16x2', offset: 28, shaderLocation: 13}, |
| {format: 'sint32x3', offset: 20, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 6}, |
| {format: 'uint16x4', offset: 12, shaderLocation: 15}, |
| ], |
| }, |
| { |
| arrayStride: 152, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x2', offset: 56, shaderLocation: 14}], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw'}, |
| }); |
| try { |
| globalThis.someLabel = veryExplicitBindGroupLayout10.label; |
| } catch {} |
| let buffer86 = device0.createBuffer({size: 312, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 989}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer57, 'uint16', 6, 61); |
| } catch {} |
| try { |
| renderBundleEncoder1.setBindGroup(1, bindGroup31); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(20, 189); |
| let img1 = await imageWithData(49, 20, '#10101010', '#20202020'); |
| let buffer87 = device0.createBuffer({ |
| size: 136, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture100 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView112 = texture70.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup39, new Uint32Array(1492), 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer80, 'uint16', 28, 8); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer65, 20); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u2a3c'); |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup48, new Uint32Array(212), 15, 2); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer55, 'uint16', 8, 2); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer25, 0, 14); |
| } catch {} |
| document.body.prepend(canvas1); |
| let renderPassEncoder12 = commandEncoder30.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: 768.4, g: 245.9, b: -820.7, a: -616.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(2, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer6, 'uint32', 8, 20); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer57, 'uint32', 12, 10); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt470m', transfer: 'pq'} }); |
| let texture101 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture102 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder16.setBindGroup(2, bindGroup38); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1, 3, 1); }; |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer24, 'uint32', 4, 23); |
| } catch {} |
| try { |
| commandEncoder70.resolveQuerySet(querySet0, 269, 2, buffer33, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(2).fill(190), /* required buffer size: 2 */ |
| {offset: 2}, {width: 50, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup60 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 16, resource: {buffer: buffer22, size: 132}}, |
| {binding: 65, resource: externalTexture11}, |
| {binding: 4, resource: textureView17}, |
| ], |
| }); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer24, 'uint16', 12, 3); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 262, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(3); }; |
| } catch {} |
| let img2 = await imageWithData(129, 23, '#10101010', '#20202020'); |
| let texture103 = device0.createTexture({ |
| size: [414, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView113 = texture74.createView({}); |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| commandEncoder34.copyBufferToBuffer(buffer74, 28, buffer47, 0, 0); |
| } catch {} |
| document.body.prepend(canvas1); |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'bt470m', transfer: 'gamma22curve'} }); |
| let videoFrame18 = new VideoFrame(videoFrame7, {timestamp: 0}); |
| let texture104 = device0.createTexture({ |
| size: {width: 207, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup18, new Uint32Array(2198), 84, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer60, 'uint16', 8, 53); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup18, new Uint32Array(2407), 563, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let texture105 = device0.createTexture({ |
| size: {width: 1656, height: 1, depthOrArrayLayers: 29}, |
| mipLevelCount: 3, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder13 = commandEncoder49.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: 161.5, g: -491.3, b: 363.3, a: -413.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer84, 'uint32', 0, 19); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 311, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let sampler13 = device0.createSampler({addressModeU: 'clamp-to-edge', lodMaxClamp: 78.87}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup48, new Uint32Array(415), 8, 2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder83.copyTextureToTexture({ |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 33, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer77, 80, new DataView(new Uint8Array(2105).map((_, i) => i).buffer), 318, 128); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas1.getContext('webgpu'); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup6, new Uint32Array(868), 7, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer0, 4); }; |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup57, new Uint32Array(1063), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer36, 0, 1); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture76, |
| mipLevel: 0, |
| origin: {x: 432, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(68).fill(67), /* required buffer size: 68 */ |
| {offset: 68, bytesPerRow: 170, rowsPerImage: 57}, {width: 20, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup0, new Uint32Array(622), 57, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer6, 'uint16', 32, 6); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| @group(0) @binding(7) var<storage, read_write> buffer90: array<array<array<array<array<array<array<f16, 1>, 1>, 1>, 3>, 1>, 1>, 28>; |
| |
| struct FragmentInput14 { |
| @location(2) location_2: vec2u, |
| @location(4) location_4: vec4i, |
| @location(14) @interpolate(flat, centroid) location_14: vec2i, |
| @location(8) location_8: f32, |
| @builtin(position) position: vec4f, |
| } |
| |
| struct VertexOutput4 { |
| @location(4) @interpolate(perspective, either) location_4: vec4h, |
| @location(0) location_0: i32, |
| @location(11) @interpolate(flat, first) location_11: u32, |
| @location(3) @interpolate(flat, center) location_3: vec2i, |
| @location(13) @interpolate(perspective, first) location_13: vec2h, |
| @location(2) location_2: u32, |
| @location(7) @interpolate(perspective, either) location_7: f16, |
| @location(15) @interpolate(perspective) location_15: vec4f, |
| @builtin(position) position: vec4f, |
| @location(1) @interpolate(flat, either) location_1: vec4f, |
| @location(9) location_9: vec2u, |
| } |
| |
| @id(47734) override override12: u32; |
| |
| @id(29694) override override7 = 0.1209e10; |
| |
| @id(15691) override override21: u32 = (942008513 % 103) + 1; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| override override18: u32; |
| |
| var<private> vp6 = frexp(vec3h(199.9, 741.0, 6960.6)); |
| |
| /* used global variables: buffer90, buffer92, buffer94, st22 */ |
| fn fn0() -> array<f32, 1> { |
| var out: array<f32, 1>; |
| let ptr47: ptr<storage, array<f16, 1>, read_write> = &(*&buffer90)[unconst_u32(3742561329)][0][unconst_u32(911882079)][unconst_u32(480724591)][0][unconst_u32(1068495123)]; |
| buffer92 -= vec4i(i32(override18)); |
| let ptr48: ptr<storage, vec2i, read_write> = &buffer94[unconst_u32(710825750)][unconst_u32(1273347213)].location_14; |
| let ptr49: ptr<storage, array<f16, 1>, read_write> = &buffer90[27][unconst_u32(372331493)][0][2][0][u32(buffer90[27][0][0][2][0][0][0])]; |
| buffer94[unconst_u32(2899639157)][unconst_u32(320982413)] = FragmentInput14(vec2u(u32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])), vec4i(i32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])), vec2i(i32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0])), f32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0]), vec4f(f32(buffer90[u32((*&buffer90)[unconst_u32(228673588)][unconst_u32(282099071)][unconst_u32(289335779)][2][0][0][0])][unconst_u32(2307777921)][unconst_u32(464591818)][unconst_u32(856490110)][0][0][0]))); |
| let ptr50: ptr<storage, array<f16, 1>, read_write> = &(*&buffer90)[u32((*&buffer90)[unconst_u32(208790966)][0][unconst_u32(699546556)][2][unconst_u32(144018230)][unconst_u32(498294928)][unconst_u32(38511700)])][0][unconst_u32(529685497)][unconst_u32(629088562)][0][0]; |
| out[0] = f32((*&buffer90)[unconst_u32(745166380)][0][unconst_u32(453314143)][unconst_u32(573076871)][u32(buffer90[unconst_u32(475505380)][unconst_u32(313919393)][0][2][0][0][0])][0][unconst_u32(260320816)]); |
| textureStore(st22, unconst_i32(-473193107), vec4i(vec4i(unconst_i32(1064722282), unconst_i32(195439993), unconst_i32(169503257), unconst_i32(485943439)))); |
| let ptr51: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 3>, read_write> = &buffer90[unconst_u32(1179105005)][u32(buffer90[unconst_u32(492887668)][0][u32(buffer90[27][0][u32(buffer90[unconst_u32(708566509)][unconst_u32(2113386480)][0][2][0][0][0])][unconst_u32(1672061488)][0][unconst_u32(12274497)][unconst_u32(285903621)])][2][0][unconst_u32(313996960)][unconst_u32(788755813)])][0]; |
| return out; |
| _ = override18; |
| _ = buffer92; |
| _ = st22; |
| _ = buffer94; |
| _ = buffer90; |
| } |
| |
| struct FragmentOutput6 { |
| @location(0) @interpolate(perspective) location_0: vec4f, |
| } |
| |
| @group(0) @binding(4) var<storage, read> buffer89: array<array<f16, 107>>; |
| |
| override override22: bool; |
| |
| override override20: bool; |
| |
| @id(13798) override override13: u32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @id(38197) override override11: u32 = (919790132 % 103) + 1; |
| |
| @group(0) @binding(153) var<storage, read_write> buffer94: array<array<FragmentInput14, 13>>; |
| |
| @group(0) @binding(1) var<uniform> buffer88: array<array<FragmentOutput6, 3>, 1>; |
| |
| @id(18962) override override8: f16 = 4044.5; |
| |
| override override16 = true; |
| |
| @id(52306) override override9: f32; |
| |
| @group(0) @binding(49) var<storage, read_write> buffer92: vec4i; |
| |
| @id(35769) override override17: bool; |
| |
| @group(0) @binding(308) var st22: texture_storage_1d<r32sint, read_write>; |
| |
| @group(0) @binding(59) var<storage, read_write> buffer93: array<FragmentOutput6, 22>; |
| |
| var<private> vp8: array<vec2u, 24> = array(vec2u(775132986, 1050140349), vec2u(899207308, 1470137705), vec2u(450205710, 814223425), vec2u(158206980, 999358468), vec2u(30929791, 528693183), vec2u(1006499267, 1807149715), vec2u(553905187, 46103328), vec2u(691141676, 61766259), vec2u(1296480673, 1355766067), vec2u(344049842, 4294967295), vec2u(515538846, 754572819), vec2u(116311861, 102080851), vec2u(142414183, 2362300655), vec2u(634339918, 222291542), vec2u(355458764, 263764587), vec2u(136966529, 142131010), vec2u(869497747, 141575210), vec2u(21966086, 1358432344), vec2u(1907302602, 258583563), vec2u(58961460, 501596187), vec2u(766609360, 1748218547), vec2u(326801547, 307820495), vec2u(1749426723, 16511329), vec2u(508012755, 176146719)); |
| |
| struct T0 { |
| @size(448) f0: vec4<bool>, |
| f1: array<atomic<i32>>, |
| } |
| |
| override override15: f16 = 6251.1; |
| |
| override override10: u32; |
| |
| @id(44718) override override19 = true; |
| |
| /* used global variables: buffer90 */ |
| fn fn1() -> bool { |
| var out: bool; |
| let ptr52: ptr<storage, array<f16, 1>, read_write> = &buffer90[27][0][unconst_u32(636759984)][unconst_u32(235258910)][0][unconst_u32(310557151)]; |
| vp8[23] >>= vec2u(u32(buffer90[unconst_u32(2285315808)][unconst_u32(1139893326)][unconst_u32(470298479)][unconst_u32(478251030)][unconst_u32(176318784)][unconst_u32(273487194)][unconst_u32(489973403)])); |
| return out; |
| _ = buffer90; |
| } |
| |
| var<private> vp7: vec4i = vec4i(74567743, 319919167, 364797100, 4121778); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(10) var<storage, read_write> buffer91: array<array<array<f16, 24>, 64>>; |
| |
| override override14: u32 = (976871902 % 103) + 1; |
| |
| /* used global variables: buffer88, buffer89 */ |
| @vertex |
| fn vertex5(@location(2) location_2: vec2u, @builtin(vertex_index) vertex_index: u32, @location(13) @interpolate(flat, sample) location_13: vec2u, @location(10) location_10: vec4u) -> VertexOutput4 { |
| var out: VertexOutput4; |
| loop { |
| out.location_15 -= bitcast<vec4f>(out.location_3.xxyx.aggg.zwyx); |
| let ptr53: ptr<uniform, FragmentOutput6> = &buffer88[0][unconst_u32(232669079)]; |
| break; |
| _ = buffer88; |
| } |
| out.location_13 = bitcast<vec2h>(arrayLength(&buffer89)); |
| vp7 ^= vec4i(i32(out.location_11)); |
| return out; |
| _ = buffer89; |
| _ = buffer88; |
| } |
| |
| /* used global variables: buffer90, buffer91 */ |
| @fragment |
| fn fragment8(a0: FragmentInput14) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| { |
| vp8[unconst_u32(108955905)] *= vec2u(u32(buffer91[arrayLength(&buffer91)][63][23])); |
| while bool((*&buffer90)[unconst_u32(68627032)][0][unconst_u32(1678480319)][2][unconst_u32(129641129)][unconst_u32(335475663)][0]) { |
| let ptr54: ptr<storage, f16, read_write> = &(*&buffer90)[unconst_u32(681667515)][0][unconst_u32(716807804)][2][0][unconst_u32(1886146315)][unconst_u32(594268000)]; |
| discard; |
| _ = buffer90; |
| } |
| var vf34 = fn1(); |
| let ptr55: ptr<storage, array<f16, 1>, read_write> = &buffer90[unconst_u32(595450974)][0][0][override12][unconst_u32(1021825786)][0]; |
| loop { |
| fn1(); |
| let ptr56: ptr<private, vec3i> = &vp6.exp; |
| var vf35 = fn1(); |
| vf35 = bool(buffer90[unconst_u32(468404472)][0][u32((*&buffer90)[27][0][0][unconst_u32(373280696)][unconst_u32(279655394)][0][unconst_u32(62162733)])][unconst_u32(828484021)][0][0][0]); |
| break; |
| _ = buffer90; |
| } |
| var vf36 = fn1(); |
| _ = override12; |
| _ = buffer91; |
| _ = buffer90; |
| } |
| out.location_0 -= vec4f(f32((*&buffer90)[unconst_u32(94279634)][unconst_u32(1088072114)][0][unconst_u32(1026081566)][unconst_u32(187567517)][unconst_u32(359931366)][unconst_u32(311858188)])); |
| var vf37 = fn1(); |
| fn1(); |
| vp8[23] |= vec2u(fma(vec3h(unconst_f16(-25741.3), unconst_f16(1597.5), unconst_f16(10052.9)), vec3h(unconst_f16(1174.3), unconst_f16(13083.3), unconst_f16(-2735.5)), vec3h(unconst_f16(8148.9), unconst_f16(5261.1), unconst_f16(10969.4))).yx.yx); |
| fn1(); |
| let ptr57: ptr<storage, f16, read_write> = &(*&buffer90)[unconst_u32(874069850)][unconst_u32(64040582)][unconst_u32(534572942)][unconst_u32(114436647)][unconst_u32(3279143683)][0][0]; |
| return out; |
| _ = override12; |
| _ = buffer90; |
| _ = buffer91; |
| } |
| |
| /* used global variables: buffer90, buffer92, buffer93 */ |
| @compute @workgroup_size(4, 1, 1) |
| fn compute6(@builtin(global_invocation_id) global_invocation_id: vec3u) { |
| let ptr58: ptr<storage, array<array<array<array<f16, 1>, 1>, 1>, 3>, read_write> = &buffer90[27][unconst_u32(1218020453)][0]; |
| let ptr59: ptr<storage, array<array<f16, 1>, 1>, read_write> = &buffer90[27][0][unconst_u32(768283106)][2][0]; |
| vp6 = frexp(vec3h((*&buffer93)[21].location_0.brr.yzy.yzx.rgg)); |
| buffer92 ^= vec4i(i32((*&buffer90)[27][unconst_u32(118798853)][0][unconst_u32(335914999)][0][u32(buffer90[unconst_u32(111441394)][unconst_u32(716008635)][0][2][unconst_u32(1220734868)][unconst_u32(784130653)][0])][unconst_u32(675371861)])); |
| _ = buffer93; |
| _ = buffer92; |
| _ = buffer90; |
| }`, |
| }); |
| let buffer95 = device0.createBuffer({size: 181, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame11, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder13.setVertexBuffer(7, buffer25); |
| } catch {} |
| try { |
| commandEncoder34.copyBufferToTexture({ |
| /* bytesInLastRow: 1704 widthInBlocks: 213 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 6616 */ |
| offset: 6616, |
| bytesPerRow: 23808, |
| buffer: buffer85, |
| }, { |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 3}, |
| aspect: 'all', |
| }, {width: 213, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder17.resolveQuerySet(querySet0, 335, 5, buffer25, 0); |
| } catch {} |
| let buffer96 = device0.createBuffer({size: 128, usage: GPUBufferUsage.INDEX}); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let renderPassEncoder14 = commandEncoder81.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: -824.2, g: 366.7, b: -889.7, a: -434.2, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup57, new Uint32Array(2700), 228, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer36, 'uint32', 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer58); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder86.copyBufferToTexture({ |
| /* bytesInLastRow: 256 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 360 */ |
| offset: 360, |
| bytesPerRow: 14336, |
| buffer: buffer85, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 137, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 64, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture58, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(2_133).fill(197), /* required buffer size: 2_133 */ |
| {offset: 316, bytesPerRow: 79, rowsPerImage: 23}, {width: 0, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 3} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 82, y: 35 }, |
| flipY: true, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 48, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 19, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await shaderModule5.getCompilationInfo(); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(34, 492); |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', minBindingSize: 10, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 73, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 154, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup61 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 93, resource: textureView5}]}); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['bgra8unorm-srgb'], depthReadOnly: true, stencilReadOnly: false}); |
| try { |
| device0.queue.writeBuffer(buffer45, 8, new Float64Array(49430).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/49429)), 7598, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder85.copyTextureToTexture({ |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 40, new Uint32Array(856).map((_, i) => i * 3), 56, 0); |
| } catch {} |
| let buffer97 = device0.createBuffer({size: 24315, usage: GPUBufferUsage.VERTEX, mappedAtCreation: false}); |
| let textureView114 = texture30.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(7, buffer6, 8, 11); |
| } catch {} |
| let textureView115 = texture96.createView({dimension: '2d-array'}); |
| let texture106 = device0.createTexture({ |
| size: [207, 1, 1], |
| mipLevelCount: 3, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer85, 7_744); }; |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(554); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer80, 'uint32', 12, 44); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData9 = new ImageData(72, 4); |
| let commandEncoder90 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer98 = device0.createBuffer({size: 292, usage: GPUBufferUsage.INDEX}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroupsIndirect(buffer60, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(3, buffer76, 0, 6); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup32); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| buffer66.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer74, 28, new Float32Array(10908).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.877)), 70, 20); |
| } catch {} |
| document.body.append(img2); |
| let img3 = await imageWithData(5, 60, '#10101010', '#20202020'); |
| let texture107 = device0.createTexture({ |
| size: [690, 1, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView116 = texture52.createView({dimension: '1d', baseMipLevel: 0}); |
| try { |
| computePassEncoder19.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer24, 'uint32', 16, 4); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(2, bindGroup35, new Uint32Array(2557), 1_030, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setVertexBuffer(0, buffer58, 0, 15); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(146); }; |
| } catch {} |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame17}); |
| let imageData10 = new ImageData(88, 36); |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let textureView117 = texture21.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(607); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| await shaderModule7.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder75.copyBufferToTexture({ |
| /* bytesInLastRow: 616 widthInBlocks: 154 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 184 */ |
| offset: 184, |
| bytesPerRow: 16640, |
| buffer: buffer56, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 154, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer80, 0, new DataView(new ArrayBuffer(82052)), 1282, 12); |
| } catch {} |
| let texture108 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer84); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| document.body.append(img3); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder13.setBindGroup(3, bindGroup54, new Uint32Array(1215), 599, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer87, 0, 3); |
| } catch {} |
| try { |
| renderBundleEncoder1.setPipeline(pipeline11); |
| } catch {} |
| let bindGroup62 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 116, resource: textureView4}, |
| {binding: 17, resource: externalTexture9}, |
| {binding: 109, resource: textureView33}, |
| {binding: 308, resource: textureView50}, |
| {binding: 524, resource: textureView85}, |
| {binding: 3, resource: textureView41}, |
| {binding: 1, resource: {buffer: buffer87, offset: 0}}, |
| {binding: 153, resource: {buffer: buffer15, offset: 0}}, |
| {binding: 5, resource: externalTexture9}, |
| {binding: 159, resource: sampler6}, |
| {binding: 59, resource: {buffer: buffer46}}, |
| {binding: 0, resource: textureView32}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 2, resource: externalTexture15}, |
| {binding: 49, resource: {buffer: buffer15}}, |
| {binding: 4, resource: {buffer: buffer46}}, |
| {binding: 312, resource: sampler0}, |
| {binding: 61, resource: textureView30}, |
| {binding: 7, resource: {buffer: buffer81}}, |
| ], |
| }); |
| let buffer99 = device0.createBuffer({size: 276, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let textureView118 = texture11.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer26, 8); }; |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder2.insertDebugMarker('\u05fd'); |
| } catch {} |
| let buffer100 = device0.createBuffer({size: 48, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let texture109 = device0.createTexture({ |
| size: [690, 1, 24], |
| mipLevelCount: 3, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup4, new Uint32Array(1368), 908, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer66, 'uint16', 4, 0); |
| } catch {} |
| try { |
| buffer22.unmap(); |
| } catch {} |
| let pipeline18 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let commandEncoder94 = device0.createCommandEncoder(); |
| let texture110 = device0.createTexture({ |
| size: [4, 4, 34], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer85, 14_244); }; |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup47, new Uint32Array(2487), 117, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer6, 'uint32', 36, 6); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline16); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let textureView119 = texture86.createView({dimension: '2d-array'}); |
| let texture111 = device0.createTexture({ |
| size: [1380, 1, 1], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder26.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer98, 'uint16', 38, 9); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(6, buffer97, 2_536, 5_979); |
| } catch {} |
| try { |
| commandEncoder75.resolveQuerySet(querySet0, 439, 2, buffer26, 0); |
| } catch {} |
| let texture112 = device0.createTexture({ |
| size: [207, 1, 1], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup12, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder14); computePassEncoder14.dispatchWorkgroupsIndirect(buffer82, 8); }; |
| } catch {} |
| let arrayBuffer3 = buffer61.getMappedRange(40, 24); |
| try { |
| commandEncoder31.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 184 */ |
| offset: 184, |
| buffer: buffer79, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData11 = new ImageData(16, 12); |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup60, new Uint32Array(290), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(96); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer57, 'uint32', 28, 8); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer45, 44, 15); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup24); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer38, 'uint16', 6, 1); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer97, 0, 6_048); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder38.resolveQuerySet(querySet1, 35, 2, buffer99, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let gpuCanvasContext3 = offscreenCanvas2.getContext('webgpu'); |
| let recycledExplicitBindGroupLayout11 = pipeline0.getBindGroupLayout(1); |
| let bindGroup63 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 239, resource: {buffer: buffer22, size: 127}}, |
| {binding: 25, resource: {buffer: buffer74, size: 44}}, |
| {binding: 2, resource: textureView35}, |
| ], |
| }); |
| let commandEncoder95 = device0.createCommandEncoder(); |
| let texture113 = device0.createTexture({ |
| size: [1656, 1, 431], |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture114 = device0.createTexture({ |
| size: {width: 828, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup12); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise11; |
| } catch {} |
| let bindGroup64 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 17, resource: externalTexture3}, |
| {binding: 5, resource: externalTexture10}, |
| {binding: 159, resource: sampler13}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 4, resource: {buffer: buffer15}}, |
| {binding: 524, resource: textureView85}, |
| {binding: 3, resource: textureView0}, |
| {binding: 0, resource: textureView32}, |
| {binding: 49, resource: {buffer: buffer55}}, |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 2, resource: externalTexture7}, |
| {binding: 1, resource: {buffer: buffer42}}, |
| {binding: 109, resource: textureView33}, |
| {binding: 312, resource: sampler0}, |
| {binding: 116, resource: textureView4}, |
| {binding: 308, resource: textureView51}, |
| {binding: 59, resource: {buffer: buffer22, size: 356}}, |
| {binding: 7, resource: {buffer: buffer61}}, |
| {binding: 61, resource: textureView7}, |
| ], |
| }); |
| let texture115 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 68}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let videoFrame19 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let texture116 = device0.createTexture({ |
| size: [256, 256, 19], |
| mipLevelCount: 3, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture117 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView120 = texture50.createView({mipLevelCount: 1, arrayLayerCount: 5}); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup60, new Uint32Array(117), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer36, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline14); |
| } catch {} |
| let buffer101 = device0.createBuffer({size: 136, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let commandBuffer10 = commandEncoder21.finish(); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup1, new Uint32Array(839), 96, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer4, 'uint16', 0, 0); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout5 = pipeline10.getBindGroupLayout(1); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let texture118 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 120}, |
| dimension: '2d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder24.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder8.insertDebugMarker('\u0fce'); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 8, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 10, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 17, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 60, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 158, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 227, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let bindGroup65 = device0.createBindGroup({label: '\u2013\u5b02', layout: autogeneratedBindGroupLayout0, entries: []}); |
| let texture119 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 16}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer84); |
| } catch {} |
| try { |
| commandEncoder74.copyBufferToTexture({ |
| /* bytesInLastRow: 800 widthInBlocks: 100 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 5144 */ |
| offset: 5144, |
| bytesPerRow: 9216, |
| buffer: buffer85, |
| }, { |
| texture: texture109, |
| mipLevel: 2, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 100, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture120 = device0.createTexture({ |
| size: {width: 1380, height: 1, depthOrArrayLayers: 269}, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup61, []); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(0, buffer3, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer77, 120, new Uint32Array(7795).map((_, i) => i * 1), 1087, 12); |
| } catch {} |
| let pipeline19 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| let buffer102 = device0.createBuffer({ |
| size: 312, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder98 = device0.createCommandEncoder(); |
| let textureView121 = texture120.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let imageData12 = new ImageData(20, 8); |
| let buffer103 = device0.createBuffer({size: 132, usage: GPUBufferUsage.INDIRECT}); |
| let texture121 = device0.createTexture({ |
| size: [1380, 1, 45], |
| dimension: '2d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture122 = device0.createTexture({ |
| size: [1656, 1, 1], |
| mipLevelCount: 9, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder15 = commandEncoder73.beginRenderPass({ |
| label: '\u{1fcf8}\u0955\uc5ce\u{1f605}\u{1f725}\ube6a\u01c3\u0980\uc5cf', |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: -245.1, g: 473.2, b: -112.4, a: -413.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder26.setPipeline(pipeline19); |
| } catch {} |
| let buffer104 = device0.createBuffer({size: 28, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let commandBuffer11 = commandEncoder0.finish(); |
| let texture123 = device0.createTexture({ |
| size: {width: 828, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 10, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture124 = device0.createTexture({ |
| size: [2760, 1, 37], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder16 = commandEncoder90.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| clearValue: { r: -6.809, g: -369.7, b: -808.8, a: 224.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup64, new Uint32Array(4996), 531, 2); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(353); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(5, buffer82, 0, 38); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer24, 'uint16', 8, 16); |
| } catch {} |
| let arrayBuffer4 = buffer61.getMappedRange(80, 8); |
| try { |
| commandEncoder83.copyBufferToTexture({ |
| /* bytesInLastRow: 1820 widthInBlocks: 455 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 852 */ |
| offset: 852, |
| bytesPerRow: 30208, |
| buffer: buffer85, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 65, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 455, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(22).fill(30), /* required buffer size: 22 */ |
| {offset: 22}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'unspecified'} }); |
| let bindGroup66 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView1}]}); |
| let texture125 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 1}, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture126 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 38}, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(2, bindGroup58, new Uint32Array(864), 250, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer36, 0); }; |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder71.clearBuffer(buffer45); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture127 = device0.createTexture({ |
| size: [4, 4, 1], |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'stencil8', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView122 = texture46.createView({}); |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer45, 'uint16', 10, 18); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(0, buffer23, 0); |
| } catch {} |
| let pipeline20 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {override4: 1}}}); |
| let pipeline21 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {count: 4}, |
| fragment: {module: shaderModule5, entryPoint: 'fragment5', targets: [{format: 'rgba16sint'}]}, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 0, shaderLocation: 10}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 5}, |
| {format: 'uint32', offset: 0, shaderLocation: 2}, |
| {format: 'float32', offset: 0, shaderLocation: 15}, |
| {format: 'uint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 4}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 6}, |
| {format: 'float32', offset: 0, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 0}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 8}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 28, |
| attributes: [ |
| {format: 'float16x4', offset: 8, shaderLocation: 12}, |
| {format: 'uint32x2', offset: 0, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 9}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let textureView123 = texture104.createView({dimension: '2d-array'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup57); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer35, 'uint16', 88, 32); |
| } catch {} |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let texture128 = device0.createTexture({ |
| size: [345, 1, 1], |
| mipLevelCount: 3, |
| format: 'r8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView124 = texture7.createView({arrayLayerCount: 2}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroupsIndirect(buffer32, 120); }; |
| } catch {} |
| try { |
| commandEncoder53.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2432 */ |
| offset: 2432, |
| bytesPerRow: 3840, |
| buffer: buffer85, |
| }, { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(canvas1); |
| let buffer105 = device0.createBuffer({size: 212, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let texture129 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 1}, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler14 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 50.54, compare: 'not-equal'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer0, 68); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer62, 'uint32', 8, 10); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10, commandBuffer11]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer29, 44, new DataView(new Uint8Array(2632).map((_, i) => i).buffer), 7, 16); |
| } catch {} |
| await gc(); |
| let textureView125 = texture120.createView({}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup48, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup66, new Uint32Array(1289), 61, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(644); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer76, 0, 35); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline4); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| let texture130 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView126 = texture1.createView({baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 4}); |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer84, 'uint32', 12, 15); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup53, new Uint32Array(2241), 25, 0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer3); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', minBindingSize: 10, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 73, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 154, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup67 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 1, resource: textureView107}, |
| {binding: 7, resource: textureView46}, |
| {binding: 16, resource: textureView17}, |
| {binding: 3, resource: {buffer: buffer22, size: 324}}, |
| {binding: 2, resource: {buffer: buffer46}}, |
| ], |
| }); |
| let buffer106 = device0.createBuffer({size: 4838, usage: GPUBufferUsage.QUERY_RESOLVE}); |
| let texture131 = device0.createTexture({ |
| size: {width: 1380, height: 1, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture132 = device0.createTexture({ |
| size: {width: 1656}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(7, buffer25, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 28, new Uint32Array(390).map((_, i) => i * 3), 20, 0); |
| } catch {} |
| let pipeline22 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture133 = device0.createTexture({ |
| size: [1, 1, 1], |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder3.setStencilReference(1081); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer82, 44, 21); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup19, new Uint32Array(910), 184, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline6); |
| } catch {} |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let texture134 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture135 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 43}, |
| mipLevelCount: 4, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView127 = texture53.createView({dimension: 'cube', baseArrayLayer: 4}); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame18}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup62, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder14.end(); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer62, 'uint32', 28, 37); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer97); |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder(); |
| let texture136 = device0.createTexture({ |
| size: [1656, 1, 128], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup35, []); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(3, buffer6); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer98.unmap(); |
| } catch {} |
| try { |
| commandEncoder84.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| } catch {} |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'bt709'} }); |
| try { |
| globalThis.someLabel = commandBuffer6.label; |
| } catch {} |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 6, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| {binding: 12, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: true }}, |
| { |
| binding: 48, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture137 = device0.createTexture({ |
| size: {width: 1, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture138 = device0.createTexture({ |
| size: [2, 2, 252], |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| computePassEncoder9.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup56, new Uint32Array(1439), 222, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer66, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(6, buffer25, 0, 6); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer105, 28, new DataView(new ArrayBuffer(36800)), 7635, 4); |
| } catch {} |
| document.body.append(img2); |
| let bindGroup68 = device0.createBindGroup({layout: autogeneratedBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer107 = device0.createBuffer({size: 268, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let texture139 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 19}, |
| mipLevelCount: 3, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture140 = device0.createTexture({ |
| label: '\u3aa9\u04f6\u83d8\u079c\u48e9\u083b\u078d\u13b6', |
| size: {width: 8, height: 8, depthOrArrayLayers: 60}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2760, height: 1, depthOrArrayLayers: 43} |
| */ |
| { |
| source: imageBitmap3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture135, |
| mipLevel: 0, |
| origin: {x: 426, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer108 = device0.createBuffer({size: 116, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let texture141 = device0.createTexture({ |
| size: [1, 1, 1], |
| mipLevelCount: 1, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 44, new Uint16Array(796).map((_, i) => i + 0), 408, 12); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 7} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture83, |
| mipLevel: 1, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let autogeneratedBindGroupLayout6 = pipeline17.getBindGroupLayout(1); |
| let bindGroup69 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 16, resource: textureView17}, |
| {binding: 2, resource: {buffer: buffer15}}, |
| {binding: 3, resource: {buffer: buffer15}}, |
| {binding: 1, resource: textureView109}, |
| {binding: 7, resource: textureView46}, |
| ], |
| }); |
| let textureView128 = texture139.createView({dimension: 'cube', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 3}); |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(145); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(7, buffer102, 0, 5); |
| } catch {} |
| try { |
| commandEncoder94.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 6224 */ |
| offset: 6224, |
| bytesPerRow: 11520, |
| buffer: buffer85, |
| }, { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule1}}); |
| let bindGroup70 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 3, resource: textureView75}, |
| {binding: 1, resource: {buffer: buffer17}}, |
| {binding: 17, resource: externalTexture10}, |
| {binding: 159, resource: sampler3}, |
| {binding: 59, resource: {buffer: buffer46}}, |
| {binding: 524, resource: textureView14}, |
| {binding: 7, resource: {buffer: buffer22, size: 220}}, |
| {binding: 116, resource: textureView2}, |
| {binding: 312, resource: sampler2}, |
| {binding: 2, resource: externalTexture10}, |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 0, resource: textureView32}, |
| {binding: 308, resource: textureView61}, |
| {binding: 5, resource: externalTexture9}, |
| {binding: 49, resource: {buffer: buffer79}}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 4, resource: {buffer: buffer79}}, |
| {binding: 61, resource: textureView8}, |
| {binding: 109, resource: textureView11}, |
| ], |
| }); |
| let textureView129 = texture111.createView({dimension: '2d-array', format: 'rgba16float', mipLevelCount: 1}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| commandEncoder98.copyBufferToBuffer(buffer32, 96, buffer62, 20, 24); |
| } catch {} |
| let pipeline24 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment6', |
| targets: [{ |
| format: 'rgba16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule4, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 64, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32x2', offset: 0, shaderLocation: 13}, |
| {format: 'uint32x2', offset: 20, shaderLocation: 11}, |
| {format: 'uint32x4', offset: 12, shaderLocation: 10}, |
| {format: 'unorm16x2', offset: 8, shaderLocation: 7}, |
| {format: 'snorm8x2', offset: 6, shaderLocation: 8}, |
| {format: 'float32x3', offset: 4, shaderLocation: 6}, |
| {format: 'uint32x2', offset: 20, shaderLocation: 15}, |
| {format: 'unorm16x4', offset: 0, shaderLocation: 0}, |
| {format: 'uint32', offset: 20, shaderLocation: 1}, |
| {format: 'float32x3', offset: 4, shaderLocation: 14}, |
| {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 5}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 2}, |
| {format: 'snorm8x4', offset: 4, shaderLocation: 12}, |
| {format: 'uint8x4', offset: 12, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 40, |
| stepMode: 'instance', |
| attributes: [{format: 'sint32x3', offset: 0, shaderLocation: 4}, {format: 'sint32x3', offset: 0, shaderLocation: 3}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', cullMode: 'front'}, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup3, new Uint32Array(1291), 234, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(863); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer24, 'uint32', 4, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer36, 0, 0); |
| } catch {} |
| let arrayBuffer5 = buffer61.getMappedRange(64, 0); |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0); }; |
| } catch {} |
| let textureView130 = texture6.createView({dimension: '1d', format: 'r32sint'}); |
| try { |
| renderPassEncoder3.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer35, 'uint16', 118, 21); |
| } catch {} |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout9, veryExplicitBindGroupLayout22]}); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let texture142 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup34, new Uint32Array(4999), 1_802, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(5, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline24); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView131 = texture94.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup44, new Uint32Array(933), 141, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup29, new Uint32Array(1146), 32, 0); |
| } catch {} |
| await gc(); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup0, new Uint32Array(579), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer6, 'uint16', 40, 1); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup5, new Uint32Array(1092), 278, 0); |
| } catch {} |
| try { |
| buffer35.unmap(); |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout15, |
| entries: [ |
| {binding: 154, resource: textureView98}, |
| {binding: 0, resource: {buffer: buffer81}}, |
| {binding: 4, resource: textureView87}, |
| {binding: 73, resource: {buffer: buffer46}}, |
| ], |
| }); |
| try { |
| computePassEncoder22.setBindGroup(3, bindGroup17, new Uint32Array(721), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer38, 'uint32', 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(2, buffer65); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(80, 500); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let texture143 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 332}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup24, new Uint32Array(742), 48, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer98, 'uint16', 2, 47); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let bindGroup72 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 16, resource: textureView17}, |
| {binding: 7, resource: textureView46}, |
| {binding: 2, resource: {buffer: buffer42, size: 4}}, |
| {binding: 3, resource: {buffer: buffer46}}, |
| {binding: 1, resource: textureView15}, |
| ], |
| }); |
| let texture144 = device0.createTexture({size: {width: 345}, dimension: '1d', format: 'bgra8unorm-srgb', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup47, new Uint32Array(2137), 371, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer84, 'uint32', 32, 40); |
| } catch {} |
| try { |
| renderPassEncoder3.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline14); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let commandBuffer12 = commandEncoder5.finish(); |
| let textureView132 = texture142.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder9.setBlendConstant({ r: -974.7, g: -48.84, b: 18.33, a: 587.0, }); |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2760, height: 1, depthOrArrayLayers: 120} |
| */ |
| { |
| source: imageBitmap3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture118, |
| mipLevel: 0, |
| origin: {x: 183, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView133 = texture1.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 9, arrayLayerCount: 4}); |
| let renderPassEncoder17 = commandEncoder59.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| clearValue: { r: 512.7, g: -347.8, b: -308.9, a: -931.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 30244069, |
| }); |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer95, 72); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(4, buffer102, 0, 72); |
| } catch {} |
| try { |
| await buffer78.mapAsync(GPUMapMode.READ); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(26); }; |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 93, resource: textureView5}]}); |
| let textureView134 = texture1.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 2}); |
| let computePassEncoder28 = commandEncoder28.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer22, 12); }; |
| } catch {} |
| try { |
| computePassEncoder28.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup40, new Uint32Array(139), 38, 0); |
| } catch {} |
| try { |
| commandEncoder67.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 752 */ |
| offset: 752, |
| bytesPerRow: 1024, |
| buffer: buffer85, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(81); }; |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 16, resource: textureView104}, |
| {binding: 2, resource: {buffer: buffer15, offset: 0}}, |
| {binding: 7, resource: textureView21}, |
| {binding: 3, resource: {buffer: buffer46}}, |
| {binding: 1, resource: textureView44}, |
| ], |
| }); |
| let buffer109 = device0.createBuffer({size: 304, usage: GPUBufferUsage.INDEX}); |
| let textureView135 = texture139.createView({dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 4}); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup7, new Uint32Array(118), 50, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline24); |
| } catch {} |
| try { |
| commandEncoder83.clearBuffer(buffer63); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup44, new Uint32Array(2134), 90, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup4, new Uint32Array(4865), 358, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer98, 'uint32', 36, 23); |
| } catch {} |
| try { |
| buffer109.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer79, 40, new Float32Array(1921).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 1.967)), 396, 8); |
| } catch {} |
| let gpuCanvasContext4 = offscreenCanvas3.getContext('webgpu'); |
| let imageBitmap4 = await createImageBitmap(imageData8); |
| let bindGroup75 = device0.createBindGroup({layout: autogeneratedBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let texture145 = device0.createTexture({ |
| size: [1380, 1, 69], |
| mipLevelCount: 5, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup65); |
| } catch {} |
| try { |
| computePassEncoder11.dispatchWorkgroups(1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup18, new Uint32Array(1203), 68, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(2, buffer97); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 16, new Float32Array(153).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + -0.4487)), 22, 4); |
| } catch {} |
| try { |
| renderPassEncoder3.label = '\u0778\u1483\u2837\u41b9\u{1fc68}'; |
| } catch {} |
| let bindGroup76 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [ |
| {binding: 16, resource: {buffer: buffer34}}, |
| {binding: 4, resource: textureView45}, |
| {binding: 65, resource: externalTexture10}, |
| ], |
| }); |
| try { |
| computePassEncoder13.end(); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer109, 'uint16', 230, 4); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let computePassEncoder29 = commandEncoder77.beginComputePass(); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup64, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer22, 4); }; |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(2, buffer102, 0, 29); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(39); }; |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2760, height: 1, depthOrArrayLayers: 120} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture118, |
| mipLevel: 0, |
| origin: {x: 444, y: 0, z: 26}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let texture146 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup76, new Uint32Array(4924), 769, 0); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer55, 'uint32', 4, 13); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer6, 'uint32', 20, 8); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| document.body.prepend(canvas1); |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte432', transfer: 'gamma22curve'} }); |
| let bindGroup77 = device0.createBindGroup({layout: veryExplicitBindGroupLayout8, entries: [{binding: 93, resource: textureView5}]}); |
| let commandEncoder108 = device0.createCommandEncoder(); |
| let texture147 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView136 = texture40.createView({dimension: '2d', baseArrayLayer: 37}); |
| let computePassEncoder30 = commandEncoder88.beginComputePass(); |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(1, bindGroup6, new Uint32Array(1112), 46, 0); |
| } catch {} |
| await gc(); |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup68); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup77, new Uint32Array(3294), 44, 0); |
| } catch {} |
| try { |
| commandEncoder39.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2376 */ |
| offset: 2376, |
| buffer: buffer85, |
| }, { |
| texture: texture28, |
| mipLevel: 1, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| let imageData13 = new ImageData(16, 44); |
| let bindGroup78 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView5}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer22, 112); }; |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(460); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer84, 'uint32', 12, 9); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder43.resolveQuerySet(querySet1, 55, 19, buffer15, 0); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let autogeneratedBindGroupLayout7 = pipeline4.getBindGroupLayout(0); |
| let buffer110 = device0.createBuffer({size: 32, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX}); |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let commandBuffer13 = commandEncoder10.finish(); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup70, [0, 0]); |
| } catch {} |
| try { |
| computePassEncoder24.setBindGroup(3, bindGroup66, new Uint32Array(931), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer76, 8, 9); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture14.label; |
| } catch {} |
| let bindGroup79 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 4, resource: textureView45}, |
| {binding: 16, resource: {buffer: buffer25, size: 36}}, |
| {binding: 65, resource: externalTexture0}, |
| ], |
| }); |
| let textureView137 = texture96.createView({dimension: '2d-array'}); |
| let texture148 = device0.createTexture({ |
| size: [256, 256, 19], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView138 = texture141.createView({}); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame10}); |
| try { |
| computePassEncoder21.end(); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer96, 'uint32', 16, 12); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer38, 0, 4); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer82, 0, 15); |
| } catch {} |
| try { |
| commandEncoder97.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2056 */ |
| offset: 2056, |
| bytesPerRow: 18432, |
| buffer: buffer85, |
| }, { |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup2, new Uint32Array(5563), 1_756, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(499); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(4, buffer62, 0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(0, bindGroup56, []); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline25 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x2c068ff3}, |
| fragment: {module: shaderModule5, entryPoint: 'fragment5', constants: {}, targets: [{format: 'rgba16sint'}]}, |
| vertex: { |
| module: shaderModule7, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 4, |
| stepMode: 'instance', |
| attributes: [{format: 'uint8x2', offset: 0, shaderLocation: 13}, {format: 'uint8x4', offset: 0, shaderLocation: 10}], |
| }, |
| {arrayStride: 92, attributes: [{format: 'uint32x2', offset: 4, shaderLocation: 2}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-list', cullMode: 'back'}, |
| }); |
| let buffer111 = device0.createBuffer({size: 88, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let textureView139 = texture10.createView({dimension: '1d'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer60, 'uint32', 0, 35); |
| } catch {} |
| let texture149 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 25}, |
| mipLevelCount: 7, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 4}); |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer107, 8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer84); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 25, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 239, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer55, 'uint16', 8, 7); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup44, new Uint32Array(265), 180, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer24, 'uint16', 22, 33); |
| } catch {} |
| let texture150 = device0.createTexture({ |
| size: [345, 1, 42], |
| mipLevelCount: 3, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView140 = texture147.createView({dimension: '2d-array', format: 'rgba16sint', mipLevelCount: 1}); |
| let renderPassEncoder18 = commandEncoder75.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: 80.12, g: -271.1, b: -152.8, a: -870.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, stencilReadOnly: false}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(2, buffer6); |
| } catch {} |
| let arrayBuffer6 = buffer78.getMappedRange(0, 0); |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer6, 0, 16); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup68); |
| } catch {} |
| let arrayBuffer7 = buffer78.getMappedRange(8, 0); |
| try { |
| device0.queue.writeBuffer(buffer5, 4, new Uint32Array(12918).map((_, i) => i * 1), 1871, 0); |
| } catch {} |
| let pipeline26 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule6, constants: {}}}); |
| let texture151 = device0.createTexture({ |
| size: {width: 207, height: 1, depthOrArrayLayers: 22}, |
| sampleCount: 1, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView141 = texture111.createView({dimension: '2d-array', aspect: 'all', format: 'rgba16float', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer4, 'uint32', 0, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandBuffer14 = commandEncoder13.finish(); |
| let sampler15 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 77.62, maxAnisotropy: 12}); |
| try { |
| device0.queue.writeBuffer(buffer36, 0, new DataView(new ArrayBuffer(12668)), 31, 0); |
| } catch {} |
| await gc(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer1, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(4, buffer6, 8, 11); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(0, bindGroup74, new Uint32Array(4550), 642, 0); |
| } catch {} |
| let buffer112 = device0.createBuffer({size: 123, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder113 = device0.createCommandEncoder(); |
| let texture152 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer85, 2_676); }; |
| } catch {} |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup5, []); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer6, 'uint32', 0, 21); |
| } catch {} |
| let promise15 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, alphaToCoverageEnabled: true}, |
| fragment: { |
| module: shaderModule7, |
| constants: {47_734: 1}, |
| targets: [{ |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'src'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'dst', dstFactor: 'one-minus-src'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex3', |
| buffers: [ |
| { |
| arrayStride: 108, |
| attributes: [ |
| {format: 'unorm8x4', offset: 56, shaderLocation: 8}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 5}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 0}, |
| {format: 'uint32x3', offset: 36, shaderLocation: 9}, |
| {format: 'float32', offset: 24, shaderLocation: 6}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 7}, |
| {format: 'sint16x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 2}, |
| {format: 'uint32x4', offset: 4, shaderLocation: 13}, |
| {format: 'uint16x4', offset: 4, shaderLocation: 11}, |
| {format: 'uint16x4', offset: 8, shaderLocation: 15}, |
| {format: 'uint16x2', offset: 4, shaderLocation: 1}, |
| {format: 'sint8x2', offset: 64, shaderLocation: 3}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 10}, |
| ], |
| }, |
| {arrayStride: 16, attributes: [{format: 'unorm8x2', offset: 0, shaderLocation: 14}]}, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let bindGroup80 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout7, |
| entries: [ |
| {binding: 1, resource: {buffer: buffer58, size: 83}}, |
| {binding: 4, resource: {buffer: buffer46, size: 2432}}, |
| ], |
| }); |
| let texture153 = device0.createTexture({ |
| size: [256, 256, 120], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer80, 'uint16', 42, 5); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(0, buffer3, 172); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| let texture154 = device0.createTexture({ |
| size: [828, 1, 1], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder12.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(3, buffer6, 12); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 256, height: 256, depthOrArrayLayers: 203} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 8, y: 13, z: 29}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(77); }; |
| } catch {} |
| let imageData14 = new ImageData(32, 120); |
| try { |
| device0.queue.label = ''; |
| } catch {} |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 3}); |
| let texture155 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView142 = texture31.createView({dimension: '3d', format: 'rgba16sint', baseMipLevel: 0}); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup64, new Uint32Array(2567), 643, 2); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer55, 'uint16', 34, 38); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(3, buffer61); |
| } catch {} |
| try { |
| computePassEncoder16.pushDebugGroup('\u{1f974}'); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise16; |
| } catch {} |
| let textureView143 = texture141.createView({baseMipLevel: 0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer101, 20); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer107, 'uint16', 28, 2); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer85.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 25, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 239, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer113 = device0.createBuffer({size: 58, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let texture156 = device0.createTexture({ |
| size: [207, 1, 5], |
| mipLevelCount: 3, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView144 = texture105.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1}); |
| let renderPassEncoder19 = commandEncoder85.beginRenderPass({colorAttachments: [{view: textureView19, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup72, new Uint32Array(810), 228, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer81, 264); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 36, new DataView(new ArrayBuffer(7812)), 4, 4); |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let texture157 = device0.createTexture({ |
| size: [345, 1, 67], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView145 = texture101.createView({dimension: '2d-array', format: 'rg32uint'}); |
| let computePassEncoder31 = commandEncoder69.beginComputePass(); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer55, 'uint16', 50, 3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(2, buffer62); |
| } catch {} |
| try { |
| computePassEncoder16.popDebugGroup(); |
| } catch {} |
| try { |
| renderPassEncoder8.insertDebugMarker('\u0d9a'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| document.body.append(canvas1); |
| await gc(); |
| let commandEncoder116 = device0.createCommandEncoder(); |
| let texture158 = device0.createTexture({ |
| size: [2, 2, 1], |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView146 = texture83.createView({mipLevelCount: 1}); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba16float'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame14}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer23, 8); }; |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup19, new Uint32Array(169), 73, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer108, 'uint16', 4, 2); |
| } catch {} |
| let arrayBuffer8 = buffer61.getMappedRange(72, 0); |
| try { |
| device0.queue.writeBuffer(buffer46, 912, new DataView(new Uint8Array(2351).map((_, i) => i).buffer), 376, 368); |
| } catch {} |
| let pipeline27 = await device0.createComputePipelineAsync({ |
| label: '\u0873\ub0cc\u{1fe9e}\u{1fcab}\ua55b\u011c\uc92f', |
| layout: pipelineLayout0, |
| compute: {module: shaderModule0, constants: {override4: 1}}, |
| }); |
| let texture159 = device0.createTexture({ |
| size: {width: 1}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture160 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder29.setBindGroup(3, bindGroup31); |
| } catch {} |
| try { |
| commandEncoder54.copyBufferToBuffer(buffer59, 0, buffer74, 4, 4); |
| } catch {} |
| try { |
| commandEncoder112.clearBuffer(buffer80, 4, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({ |
| label: '\uc80d\u3825\ua9fc\u3c62\u002f', |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 61, resource: textureView27}, |
| {binding: 2, resource: externalTexture19}, |
| {binding: 312, resource: sampler14}, |
| {binding: 153, resource: {buffer: buffer15, size: 1488}}, |
| {binding: 4, resource: {buffer: buffer79}}, |
| {binding: 17, resource: externalTexture1}, |
| {binding: 1, resource: {buffer: buffer28, size: 83}}, |
| {binding: 159, resource: sampler1}, |
| {binding: 5, resource: externalTexture3}, |
| {binding: 524, resource: textureView85}, |
| {binding: 0, resource: textureView22}, |
| {binding: 109, resource: textureView23}, |
| {binding: 308, resource: textureView50}, |
| {binding: 49, resource: {buffer: buffer7}}, |
| {binding: 3, resource: textureView42}, |
| {binding: 7, resource: {buffer: buffer81}}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 59, resource: {buffer: buffer15}}, |
| {binding: 116, resource: textureView2}, |
| ], |
| }); |
| let texture161 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 22}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView147 = texture149.createView({mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 4}); |
| let computePassEncoder32 = commandEncoder87.beginComputePass(); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 59, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 61, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 109, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 153, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 308, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 312, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 524, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer114 = device0.createBuffer({size: 67, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let textureView148 = texture158.createView({dimension: '2d-array'}); |
| let textureView149 = texture155.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder33 = commandEncoder53.beginComputePass(); |
| try { |
| renderPassEncoder15.setVertexBuffer(4, buffer62, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup68); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup37, new Uint32Array(797), 71, 0); |
| } catch {} |
| try { |
| commandEncoder57.copyBufferToBuffer(buffer64, 8, buffer102, 60, 0); |
| } catch {} |
| document.body.prepend(img1); |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let textureView150 = texture159.createView({}); |
| let texture162 = device0.createTexture({ |
| size: [2, 2, 362], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder33.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout8 = pipeline16.getBindGroupLayout(0); |
| let bindGroup82 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 93, resource: textureView5}]}); |
| let textureView151 = texture27.createView({}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup72, new Uint32Array(971), 43, 0); |
| } catch {} |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setStencilReference(1783); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup21, new Uint32Array(2646), 404, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(19_171).fill(8), /* required buffer size: 19_171 */ |
| {offset: 19, bytesPerRow: 38, rowsPerImage: 72}, {width: 3, height: 0, depthOrArrayLayers: 8}); |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 5, resource: externalTexture9}, |
| {binding: 0, resource: textureView32}, |
| {binding: 159, resource: sampler10}, |
| {binding: 49, resource: {buffer: buffer55}}, |
| {binding: 116, resource: textureView2}, |
| {binding: 1, resource: {buffer: buffer58, size: 69}}, |
| {binding: 2, resource: externalTexture15}, |
| {binding: 61, resource: textureView30}, |
| {binding: 10, resource: {buffer: buffer46, size: 3284}}, |
| {binding: 59, resource: {buffer: buffer46}}, |
| {binding: 312, resource: sampler14}, |
| {binding: 3, resource: textureView57}, |
| {binding: 308, resource: textureView12}, |
| {binding: 4, resource: {buffer: buffer22, size: 232}}, |
| {binding: 17, resource: externalTexture12}, |
| {binding: 109, resource: textureView99}, |
| {binding: 524, resource: textureView35}, |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 7, resource: {buffer: buffer105}}, |
| ], |
| }); |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer105, 8); }; |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer98, 'uint32', 48, 17); |
| } catch {} |
| let arrayBuffer9 = buffer61.getMappedRange(88, 12); |
| try { |
| commandEncoder79.resolveQuerySet(querySet2, 0, 0, buffer24, 0); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let veryExplicitBindGroupLayout29 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16float', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| {binding: 5, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 10, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| {binding: 17, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 49, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 59, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 61, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 109, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 153, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 159, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 308, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 312, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 524, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup84 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [ |
| {binding: 4, resource: textureView113}, |
| {binding: 73, resource: {buffer: buffer46}}, |
| {binding: 0, resource: {buffer: buffer36}}, |
| {binding: 154, resource: textureView103}, |
| ], |
| }); |
| let sampler16 = device0.createSampler({addressModeU: 'repeat', minFilter: 'nearest', lodMaxClamp: 60.99}); |
| try { |
| computePassEncoder31.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(3, buffer3, 0, 43); |
| } catch {} |
| try { |
| renderBundleEncoder23.insertDebugMarker('\ua6cc'); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let img4 = await imageWithData(146, 72, '#10101010', '#20202020'); |
| let buffer115 = device0.createBuffer({size: 320, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let textureView152 = texture1.createView({label: '\u8df5\u00a1\u{1f805}\u88ae', dimension: 'cube', mipLevelCount: 1, baseArrayLayer: 4}); |
| let textureView153 = texture154.createView({dimension: '2d-array', format: 'rgba16uint'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer103, 44); }; |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(1, bindGroup39); |
| } catch {} |
| try { |
| commandEncoder57.copyBufferToTexture({ |
| /* bytesInLastRow: 376 widthInBlocks: 94 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3936 */ |
| offset: 3936, |
| buffer: buffer85, |
| }, { |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 100, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 94, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder32.insertDebugMarker('\u74c8'); |
| } catch {} |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let textureView154 = texture97.createView({dimension: '2d-array'}); |
| let textureView155 = texture129.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup15, new Uint32Array(722), 82, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer32, 84); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup14); |
| } catch {} |
| let commandEncoder121 = device0.createCommandEncoder(); |
| let commandBuffer15 = commandEncoder24.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 52, new DataView(new ArrayBuffer(57348)), 3147, 36); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline28 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0xdf9d069}, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment5', |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 12, |
| attributes: [ |
| {format: 'snorm16x2', offset: 0, shaderLocation: 10}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 7}, |
| {format: 'float32x2', offset: 0, shaderLocation: 9}, |
| {format: 'float16x2', offset: 0, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let imageData15 = new ImageData(68, 24); |
| let bindGroup85 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 7, resource: {buffer: buffer81, offset: 0}}, |
| {binding: 49, resource: {buffer: buffer55}}, |
| {binding: 1, resource: {buffer: buffer81, size: 145}}, |
| {binding: 116, resource: textureView4}, |
| {binding: 153, resource: {buffer: buffer46}}, |
| {binding: 4, resource: {buffer: buffer15}}, |
| {binding: 3, resource: textureView0}, |
| {binding: 5, resource: externalTexture2}, |
| {binding: 524, resource: textureView80}, |
| {binding: 0, resource: textureView32}, |
| {binding: 308, resource: textureView12}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 109, resource: textureView23}, |
| {binding: 61, resource: textureView7}, |
| {binding: 17, resource: externalTexture20}, |
| {binding: 59, resource: {buffer: buffer15}}, |
| {binding: 312, resource: sampler0}, |
| {binding: 159, resource: sampler12}, |
| {binding: 2, resource: externalTexture19}, |
| ], |
| }); |
| let textureView156 = texture74.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer108, 'uint32', 36, 8); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(3, bindGroup80, []); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 159, resource: sampler1}, |
| {binding: 524, resource: textureView80}, |
| {binding: 17, resource: externalTexture14}, |
| {binding: 1, resource: {buffer: buffer27, size: 57}}, |
| {binding: 153, resource: {buffer: buffer46}}, |
| {binding: 59, resource: {buffer: buffer15}}, |
| {binding: 109, resource: textureView23}, |
| {binding: 10, resource: {buffer: buffer46, size: 3220}}, |
| {binding: 116, resource: textureView4}, |
| {binding: 312, resource: sampler2}, |
| {binding: 4, resource: {buffer: buffer15}}, |
| {binding: 308, resource: textureView55}, |
| {binding: 2, resource: externalTexture7}, |
| {binding: 7, resource: {buffer: buffer61, size: 168}}, |
| {binding: 0, resource: textureView32}, |
| {binding: 61, resource: textureView9}, |
| {binding: 5, resource: externalTexture9}, |
| {binding: 3, resource: textureView41}, |
| {binding: 49, resource: {buffer: buffer79, size: 20}}, |
| ], |
| }); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let textureView157 = texture158.createView({dimension: '2d-array'}); |
| let texture163 = device0.createTexture({ |
| size: [414], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup28, []); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(5, buffer65, 4); |
| } catch {} |
| let arrayBuffer10 = buffer61.getMappedRange(104, 16); |
| try { |
| commandEncoder104.copyBufferToTexture({ |
| /* bytesInLastRow: 136 widthInBlocks: 34 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1816 */ |
| offset: 1816, |
| bytesPerRow: 17408, |
| buffer: buffer85, |
| }, { |
| texture: texture119, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 34, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder52.resolveQuerySet(querySet0, 646, 82, buffer106, 1792); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 28, new Float32Array(15198).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.6452)), 439, 28); |
| } catch {} |
| let commandEncoder123 = device0.createCommandEncoder(); |
| let texture164 = device0.createTexture({ |
| size: [256, 256, 19], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let externalTexture22 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup83, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(948); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer57, 'uint32', 24, 11); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer6, 68); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer108, 'uint16', 12, 98); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline24); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1, 3); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer4, 'uint16', 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, undefined, 0, 1_515_362_848); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline28); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(3, buffer81, 64, 71); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer15]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture118, |
| mipLevel: 0, |
| origin: {x: 107, y: 0, z: 9}, |
| aspect: 'all', |
| }, new Uint8Array(878_350).fill(75), /* required buffer size: 878_350 */ |
| {offset: 110, bytesPerRow: 4990, rowsPerImage: 16}, {width: 1209, height: 0, depthOrArrayLayers: 12}); |
| } catch {} |
| let promise18 = device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x92711f7b}, |
| fragment: {module: shaderModule3, targets: [{format: 'rgba16sint'}]}, |
| vertex: { |
| module: shaderModule1, |
| buffers: [ |
| { |
| arrayStride: 92, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 8, shaderLocation: 5}, |
| {format: 'float32x2', offset: 12, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 2, shaderLocation: 8}, |
| {format: 'uint32x3', offset: 0, shaderLocation: 3}, |
| {format: 'snorm8x2', offset: 22, shaderLocation: 4}, |
| {format: 'uint8x2', offset: 2, shaderLocation: 7}, |
| {format: 'unorm16x4', offset: 24, shaderLocation: 14}, |
| {format: 'unorm16x2', offset: 8, shaderLocation: 12}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 10}, |
| {format: 'uint32x3', offset: 4, shaderLocation: 2}, |
| {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 15}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 1}, |
| {format: 'float32x4', offset: 20, shaderLocation: 0}, |
| {format: 'sint16x2', offset: 32, shaderLocation: 13}, |
| {format: 'snorm8x2', offset: 30, shaderLocation: 6}, |
| ], |
| }, |
| {arrayStride: 120, attributes: [{format: 'uint32x2', offset: 16, shaderLocation: 11}]}, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back', unclippedDepth: false}, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup15, new Uint32Array(2337), 184, 0); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(2, bindGroup73, new Uint32Array(993), 77, 0); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| commandEncoder60.copyBufferToTexture({ |
| /* bytesInLastRow: 276 widthInBlocks: 69 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2440 */ |
| offset: 2440, |
| rowsPerImage: 1290, |
| buffer: buffer85, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 45, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 69, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(26); }; |
| } catch {} |
| document.body.append(canvas0); |
| let imageData16 = new ImageData(4, 100); |
| let buffer116 = device0.createBuffer({size: 520, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let commandBuffer16 = commandEncoder42.finish(); |
| let texture165 = device0.createTexture({ |
| size: [345, 1, 46], |
| mipLevelCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 96.52, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup77); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer113, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'film', transfer: 'linear'} }); |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let textureView158 = texture56.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup73, new Uint32Array(6026), 67, 0); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToBuffer(buffer32, 668, buffer107, 12, 0); |
| } catch {} |
| let bindGroup87 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 93, resource: textureView1}]}); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup36, new Uint32Array(300), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer35, 'uint32', 8, 140); |
| } catch {} |
| try { |
| computePassEncoder29.insertDebugMarker('\u0024'); |
| } catch {} |
| await gc(); |
| let texture166 = device0.createTexture({ |
| size: [2], |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView159 = texture108.createView({label: '\u026a'}); |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup61); |
| } catch {} |
| try { |
| buffer42.destroy(); |
| } catch {} |
| let buffer117 = device0.createBuffer({size: 1024, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder126 = device0.createCommandEncoder({}); |
| let computePassEncoder34 = commandEncoder26.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer60, 4); }; |
| } catch {} |
| try { |
| computePassEncoder34.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup36, new Uint32Array(6761), 1_004, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer84, 'uint32', 20, 27); |
| } catch {} |
| document.body.append(img2); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(3, bindGroup26); |
| } catch {} |
| let bindGroup88 = device0.createBindGroup({layout: veryExplicitBindGroupLayout1, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer118 = device0.createBuffer({ |
| size: 56, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder127 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup55, new Uint32Array(845), 200, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setStencilReference(1143); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer4, 'uint16', 0, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 996, new Float32Array(4679).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 0.2299)), 1599, 284); |
| } catch {} |
| let img5 = await imageWithData(76, 10, '#10101010', '#20202020'); |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup22, new Uint32Array(3254), 416, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer117, 24); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer118, 'uint16', 2, 4); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline24); |
| } catch {} |
| document.body.prepend(canvas0); |
| let bindGroup89 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 65, resource: externalTexture3}, |
| {binding: 16, resource: {buffer: buffer111}}, |
| {binding: 4, resource: textureView45}, |
| ], |
| }); |
| let commandEncoder129 = device0.createCommandEncoder(); |
| let texture167 = device0.createTexture({ |
| size: {width: 256, height: 256, depthOrArrayLayers: 19}, |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView160 = texture27.createView({aspect: 'all', baseMipLevel: 0}); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup88); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer23, 20); }; |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup21); |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 25, resource: {buffer: buffer81}}, |
| {binding: 239, resource: {buffer: buffer17}}, |
| {binding: 2, resource: textureView158}, |
| ], |
| }); |
| let commandBuffer17 = commandEncoder9.finish(); |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer45, 'uint16', 0, 2); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(0, buffer81, 28, 2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer47, 4, new DataView(new Uint8Array(16945).map((_, i) => i).buffer), 5150, 4); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture120, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 36}, |
| aspect: 'all', |
| }, new Uint8Array(555_918).fill(27), /* required buffer size: 555_918 */ |
| {offset: 420, bytesPerRow: 486, rowsPerImage: 9}, {width: 96, height: 0, depthOrArrayLayers: 128}); |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 3, resource: {buffer: buffer22, size: 348}}, |
| {binding: 1, resource: textureView76}, |
| {binding: 2, resource: {buffer: buffer100}}, |
| {binding: 16, resource: textureView17}, |
| {binding: 7, resource: textureView79}, |
| ], |
| }); |
| try { |
| renderPassEncoder10.setPipeline(pipeline24); |
| } catch {} |
| try { |
| commandEncoder111.insertDebugMarker('\u8ef4'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture75, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(181).fill(36), /* required buffer size: 181 */ |
| {offset: 181, rowsPerImage: 4}, {width: 178, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView161 = texture159.createView({}); |
| try { |
| renderBundleEncoder26.setBindGroup(1, bindGroup4, new Uint32Array(645), 20, 0); |
| } catch {} |
| try { |
| commandEncoder102.resolveQuerySet(querySet2, 0, 0, buffer106, 1792); |
| } catch {} |
| let imageData17 = new ImageData(12, 20); |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| @group(0) @binding(60) var tex15: texture_multisampled_2d<i32>; |
| |
| @group(0) @binding(116) var<storage, read_write> buffer121: array<array<array<f16, 46>, 4>>; |
| |
| struct FragmentInput15 { |
| @builtin(position) position: vec4f, |
| } |
| |
| struct ComputeInput8 { |
| @builtin(num_workgroups) num_workgroups: vec3u, |
| } |
| |
| @group(0) @binding(2) var<storage, read_write> buffer119: array<array<array<array<f16, 1>, 3>, 18>>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw25: vec4u; |
| |
| @group(0) @binding(7) var<storage, read> buffer120: array<FragmentOutput7, 12>; |
| |
| @group(0) @binding(15) var tex14: texture_2d<f32>; |
| |
| @group(0) @binding(10) var sam10: sampler; |
| |
| struct FragmentOutput7 { |
| @builtin(sample_mask) sample_mask: u32, |
| @location(0) @interpolate(perspective, sample) location_0: vec4f, |
| } |
| |
| struct FragmentInput17 { |
| @location(12) @interpolate(flat, centroid) location_12: u32, |
| @location(5) @interpolate(flat, either) location_5: f32, |
| } |
| |
| @group(0) @binding(0) var et14: texture_external; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: st23, tex14, tex15 */ |
| fn fn0() { |
| textureStore(st23, unconst_i32(135257574), vec4i(vec4i(unconst_i32(200601611), unconst_i32(194766402), unconst_i32(616324407), unconst_i32(492260522)))); |
| _ = tex15; |
| let vf38: vec2u = textureDimensions(tex14); |
| textureStore(st23, unconst_i32(1438152654), vec4i(vec4i(unconst_i32(-9207828), unconst_i32(587368422), unconst_i32(-358000832), unconst_i32(1533278555)))); |
| let vf39: vec4<bool> = (vec4f(unconst_f32(0.2562e-14), unconst_f32(0.05000e-40), unconst_f32(0.5113e35), unconst_f32(0.03819e-2)) < unpack4x8unorm(textureNumLevels(tex14))); |
| textureStore(st23, unconst_i32(155868591), vec4i(vec4i(unconst_i32(-136208690), unconst_i32(64506270), unconst_i32(1390549229), unconst_i32(-515731500)))); |
| let vf40: u32 = vf38[unconst_u32(251350984)]; |
| let vf41: u32 = vf40; |
| _ = tex15; |
| if bool(textureDimensions(tex15).r) { |
| textureStore(st23, unconst_i32(547322645), vec4i(vec4i(unconst_i32(-209479507), unconst_i32(20205905), unconst_i32(699388851), unconst_i32(-40177669)))); |
| let vf42: f16 = step(unconst_f16(184.2), unconst_f16(9490.3)); |
| textureStore(st23, unconst_i32(24030066), vec4i(vec4i(unconst_i32(-185144303), unconst_i32(140738320), unconst_i32(1070603174), unconst_i32(598853440)))); |
| textureStore(st23, unconst_i32(198736452), vec4i(vec4i(unconst_i32(2121033184), unconst_i32(545110979), unconst_i32(922751420), unconst_i32(543744065)))); |
| return; |
| _ = st23; |
| } |
| textureStore(st23, unconst_i32(103798022), vec4i(vec4i(unconst_i32(2319336), unconst_i32(135090406), unconst_i32(128516202), unconst_i32(335465463)))); |
| _ = tex14; |
| _ = st23; |
| _ = tex15; |
| } |
| |
| @group(0) @binding(1) var tex13: texture_depth_2d; |
| |
| var<workgroup> vw24: atomic<i32>; |
| |
| @group(0) @binding(3) var st23: texture_storage_1d<rgba16sint, write>; |
| |
| var<workgroup> vw22: vec2<bool>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentOutput8 { |
| @location(0) @interpolate(linear) location_0: vec4f, |
| @builtin(sample_mask) sample_mask: u32, |
| @location(5) location_5: vec4i, |
| } |
| |
| @group(0) @binding(158) var st25: texture_storage_3d<r32sint, write>; |
| |
| var<workgroup> vw23: atomic<i32>; |
| |
| struct FragmentInput18 { |
| @location(1) @interpolate(perspective) location_1: vec4f, |
| } |
| |
| struct FragmentInput16 { |
| @location(6) location_6: i32, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: tex14 */ |
| @vertex |
| fn vertex6(@location(13) location_13: vec2f) -> @builtin(position) vec4f { |
| var out: vec4f; |
| _ = tex14; |
| return out; |
| _ = tex14; |
| } |
| |
| /* used global variables: buffer120, et14, st23, st25, tex14, tex15 */ |
| @fragment |
| fn fragment9(@builtin(sample_index) sample_index: u32, @builtin(front_facing) front_facing: bool, a2: FragmentInput15) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| let vf43: i32 = dot(vec2i(unconst_i32(352383682), unconst_i32(224905303)), vec2i(unconst_i32(209040543), unconst_i32(94837066))); |
| fn0(); |
| textureStore(st23, unconst_i32(-290195862), vec4i(vec4i(unconst_i32(922455511), unconst_i32(122438683), unconst_i32(209123981), unconst_i32(-159279534)))); |
| var vf44: i32 = dot(vec2i(unconst_i32(150281062), unconst_i32(9782984)), vec2i(unconst_i32(25121621), unconst_i32(107433434))); |
| while bool(atan(unconst_f16(7660.0))) { |
| discard; |
| fn0(); |
| for (var it2=pack4x8unorm(buffer120[unconst_u32(1627184055)].location_0); it2<(pack4x8snorm(buffer120[11].location_0) & 0xfff); it2++) { |
| textureStore(st25, vec3i(unconst_i32(-98609587), unconst_i32(198671190), unconst_i32(236434293)), vec4i(vec4i(unconst_i32(72283617), unconst_i32(213452606), unconst_i32(153231797), unconst_i32(356609540)))); |
| out.location_0 = (*&buffer120)[11].location_0; |
| _ = buffer120; |
| _ = st25; |
| } |
| textureStore(st23, unconst_i32(-845067666), vec4i(vec4i(unconst_i32(499350624), unconst_i32(504742284), unconst_i32(32219398), unconst_i32(154636165)))); |
| textureStore(st23, unconst_i32(837518273), vec4i(vec4i(unconst_i32(1158671250), unconst_i32(684397184), unconst_i32(-258427419), unconst_i32(549449454)))); |
| out.location_0 = buffer120[unconst_u32(85527939)].location_0; |
| _ = tex15; |
| _ = st23; |
| _ = tex14; |
| _ = st25; |
| _ = buffer120; |
| } |
| let vf45: f32 = buffer120[unconst_u32(372612533)].location_0[unconst_u32(36264063)]; |
| fn0(); |
| let ptr60: ptr<storage, array<FragmentOutput7, 12>, read> = &(*&buffer120); |
| fn0(); |
| vf44 += insertBits(vec3i(unconst_i32(550388799), unconst_i32(147551262), unconst_i32(127336244)), bitcast<vec3i>(textureDimensions(et14).rgg), u32((*ptr60)[unconst_u32(393448472)].location_0[unconst_u32(313396283)]), textureDimensions(tex15)[0])[1]; |
| fn0(); |
| return out; |
| _ = tex14; |
| _ = st23; |
| _ = et14; |
| _ = st25; |
| _ = tex15; |
| _ = buffer120; |
| } |
| |
| /* used global variables: buffer120, st23, tex14, tex15 */ |
| @fragment |
| fn fragment10(@location(11) @interpolate(flat) location_11: vec4i, @location(8) @interpolate(flat, first) location_8: vec2u, a2: FragmentInput16, a3: FragmentInput17, a4: FragmentInput18) -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| let ptr61: ptr<storage, vec4f, read> = &buffer120[unconst_u32(703424580)].location_0; |
| var vf46: f32 = (*&buffer120)[(*&buffer120)[unconst_u32(1541729523)].sample_mask].location_0[unconst_u32(94214303)]; |
| if bool((*&buffer120)[unconst_u32(263638043)].sample_mask) { |
| let ptr62: ptr<storage, array<FragmentOutput7, 12>, read> = &buffer120; |
| fn0(); |
| let ptr63: ptr<storage, array<FragmentOutput7, 12>, read> = &(*&buffer120); |
| let ptr64: ptr<storage, vec4f, read> = &buffer120[unconst_u32(615521613)].location_0; |
| _ = tex14; |
| _ = tex15; |
| _ = st23; |
| _ = buffer120; |
| } |
| loop { |
| let ptr65: ptr<function, vec4f> = &out.location_0; |
| out.sample_mask -= pack4x8snorm((*&buffer120)[11].location_0); |
| if bool(textureNumLevels(tex14)) { |
| fn0(); |
| _ = tex14; |
| _ = tex15; |
| _ = st23; |
| } |
| break; |
| _ = tex15; |
| _ = tex14; |
| _ = buffer120; |
| _ = st23; |
| } |
| return out; |
| _ = st23; |
| _ = tex15; |
| _ = tex14; |
| _ = buffer120; |
| } |
| |
| /* used global variables: buffer119, buffer121, sam10, st23, tex13, tex14, tex15 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute7(a0: ComputeInput8) { |
| var vf47: vec4f = fma(vec4f(unconst_f32(0.01851e19), unconst_f32(0.6764), unconst_f32(0.07537), unconst_f32(0.1363e1)), vec4f(unconst_f32(0.2070), unconst_f32(0.1325), unconst_f32(-0.04097e35), unconst_f32(0.3198)), vec4f(unconst_f32(0.03020e-37), unconst_f32(0.06281), unconst_f32(-0.09973), unconst_f32(0.03530e-39))); |
| fn0(); |
| textureStore(st23, unconst_i32(46991744), vec4i(vec4i(i32(vw22[u32(buffer121[arrayLength(&buffer121)][3][unconst_u32(82715308)])])))); |
| switch atomicLoad(&vw24) { |
| default { |
| fn0(); |
| atomicOr(&vw23, i32((*&buffer119)[arrayLength(&(*&buffer119))][unconst_u32(302968274)][unconst_u32(850018728)][0])); |
| for (var jj4=0u; jj4<20; jj4++) { for (var jj6=0u; jj6<3; jj6++) { buffer119[unconst_u32(1613275247)][jj4][unconst_u32(335014650)][jj6] = f16(arrayLength(&(*&buffer119))); } } |
| for (var ii4=0u; ii4<0x1000; ii4+=0x11) { for (var jj27=0u; jj27<20; jj27++) { for (var jj82=0u; jj82<3; jj82++) { buffer119[ii4][jj27][unconst_u32(510473887)][jj82] *= (*&buffer121)[arrayLength(&(*&buffer121))][bitcast<u32>(textureSampleLevel(tex13, sam10, vec2f(bitcast<f32>(atomicExchange(&(*&vw23), unconst_i32(-190860862)))), unconst_i32(158219427)))][45]; } } } |
| let ptr66: ptr<storage, f16, read_write> = &(*&buffer121)[arrayLength(&(*&buffer121))][3][unconst_u32(3334477740)]; |
| return; |
| _ = tex13; |
| _ = buffer121; |
| _ = tex15; |
| _ = st23; |
| _ = tex14; |
| _ = sam10; |
| _ = buffer119; |
| } |
| } |
| textureStore(st23, unconst_i32(7462161), vec4i(vec4i(unconst_i32(802776941), unconst_i32(1478641072), unconst_i32(461407004), unconst_i32(572960742)))); |
| let ptr67: ptr<storage, array<array<array<f16, 1>, 3>, 18>, read_write> = &buffer119[unconst_u32(266238168)]; |
| _ = tex14; |
| _ = st23; |
| _ = tex13; |
| _ = buffer121; |
| _ = buffer119; |
| _ = tex15; |
| _ = sam10; |
| } |
| |
| /* used global variables: buffer119, buffer121, st23, tex14, tex15 */ |
| @compute @workgroup_size(2, 1, 1) |
| fn compute8() { |
| buffer119[unconst_u32(528187122)][unconst_u32(281405273)][unconst_u32(407669089)][unconst_u32(171782565)] = f16(arrayLength(&buffer121)); |
| buffer121[unconst_u32(589716621)][unconst_u32(145161861)][unconst_u32(114337289)] = (*&buffer119)[arrayLength(&(*&buffer119))][unconst_u32(105005836)][2][0]; |
| vw25 = unpack4xU8(u32(buffer121[unconst_u32(689400235)][3][unconst_u32(296827977)])); |
| let ptr68: ptr<storage, f16, read_write> = &(*&buffer121)[arrayLength(&(*&buffer121))][unconst_u32(654045905)][45]; |
| fn0(); |
| let ptr69: ptr<storage, f16, read_write> = &(*&buffer119)[unconst_u32(88215760)][u32(buffer119[arrayLength(&buffer119)][unconst_u32(1041150117)][2][0])][unconst_u32(93927710)][0]; |
| buffer121[unconst_u32(447540459)][u32((*&buffer119)[arrayLength(&(*&buffer119))][unconst_u32(508012154)][2][unconst_u32(100701592)])][unconst_u32(1117704754)] = f16(atan2(unconst_f32(0.6058e-44), unconst_f32(0.01971e-36))); |
| fn0(); |
| buffer119[unconst_u32(795180449)][pack4xU8(bitcast<vec4u>(textureLoad(tex14, vec2i(unconst_i32(8003183), unconst_i32(542563682)), unconst_i32(378728917)).abaa.raab))][2][unconst_u32(125786150)] = buffer121[arrayLength(&buffer121)][3][unconst_u32(556386543)]; |
| fn0(); |
| atomicExchange(&vw24, unconst_i32(467469745)); |
| let ptr70: ptr<workgroup, vec2<bool>> = &(*&vw22); |
| return; |
| _ = st23; |
| _ = buffer119; |
| _ = tex15; |
| _ = tex14; |
| _ = buffer121; |
| }`, |
| }); |
| let bindGroup92 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 93, resource: textureView1}]}); |
| let renderPassEncoder20 = commandEncoder92.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: 885.4, g: -128.2, b: -891.0, a: 930.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder8.setStencilReference(302); |
| } catch {} |
| let buffer122 = device0.createBuffer({size: 161, usage: GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup69, new Uint32Array(2400), 996, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer23, 12); }; |
| } catch {} |
| try { |
| computePassEncoder22.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(7, buffer76); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(3, buffer6); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(63); }; |
| } catch {} |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder30.pushDebugGroup('\u{1fb42}'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer57, 124, new Float16Array(13664).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i * 2.935)), 145, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline29 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6}}); |
| let buffer123 = device0.createBuffer({size: 84, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: false}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(3, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer38); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(9); }; |
| } catch {} |
| let bindGroup93 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout23, |
| entries: [ |
| {binding: 2, resource: {buffer: buffer7}}, |
| {binding: 158, resource: textureView37}, |
| {binding: 10, resource: sampler1}, |
| {binding: 227, resource: textureView20}, |
| {binding: 8, resource: externalTexture12}, |
| {binding: 15, resource: textureView158}, |
| {binding: 1, resource: textureView17}, |
| {binding: 116, resource: {buffer: buffer81}}, |
| {binding: 0, resource: externalTexture12}, |
| {binding: 4, resource: sampler2}, |
| {binding: 60, resource: textureView97}, |
| {binding: 3, resource: textureView99}, |
| {binding: 17, resource: textureView92}, |
| {binding: 7, resource: {buffer: buffer81}}, |
| ], |
| }); |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'equal', |
| maxAnisotropy: 9, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer101, 52); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline24); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer47, 4, new Float32Array(15100).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.652)), 4702, 0); |
| } catch {} |
| let buffer124 = device0.createBuffer({ |
| size: 64, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder132 = device0.createCommandEncoder({}); |
| let computePassEncoder35 = commandEncoder106.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer1, 16); }; |
| } catch {} |
| try { |
| computePassEncoder35.setPipeline(pipeline7); |
| } catch {} |
| try { |
| buffer86.unmap(); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let texture168 = device0.createTexture({ |
| size: {width: 1656}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer36, 'uint16', 2, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup87, new Uint32Array(1164), 841, 0); |
| } catch {} |
| try { |
| buffer29.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'unspecified', transfer: 'pq'} }); |
| let commandBuffer18 = commandEncoder32.finish(); |
| let texture169 = device0.createTexture({ |
| size: {width: 1, height: 1, depthOrArrayLayers: 4}, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(1, bindGroup32); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer113, 0); }; |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer57, 'uint16', 44, 22); |
| } catch {} |
| let arrayBuffer11 = buffer61.getMappedRange(120, 8); |
| try { |
| computePassEncoder30.popDebugGroup(); |
| } catch {} |
| document.body.append(canvas0); |
| let veryExplicitBindGroupLayout30 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 3, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 7, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 8, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 10, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'non-filtering' }}, |
| { |
| binding: 15, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 17, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 60, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 158, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 227, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let buffer125 = device0.createBuffer({size: 44, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let texture170 = device0.createTexture({ |
| size: {width: 345, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer26, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup25); |
| } catch {} |
| let arrayBuffer12 = buffer61.getMappedRange(128, 0); |
| let bindGroup94 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout27, |
| entries: [ |
| {binding: 239, resource: {buffer: buffer27}}, |
| {binding: 25, resource: {buffer: buffer101}}, |
| {binding: 2, resource: textureView14}, |
| ], |
| }); |
| let texture171 = device0.createTexture({ |
| size: [828, 1, 59], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler19 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 78.34, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup8, new Uint32Array(1671), 64, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(3, bindGroup74, new Uint32Array(590), 71, 0); |
| } catch {} |
| try { |
| buffer59.unmap(); |
| } catch {} |
| try { |
| commandEncoder58.copyBufferToBuffer(buffer125, 0, buffer32, 204, 4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 28, new Float64Array(13311).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/13311)), 5045, 0); |
| } catch {} |
| let buffer126 = device0.createBuffer({size: 184, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM}); |
| let texture172 = device0.createTexture({size: [2760, 1, 1], mipLevelCount: 4, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture97, |
| mipLevel: 0, |
| origin: {x: 164, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(262).fill(220), /* required buffer size: 262 */ |
| {offset: 262}, {width: 19, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1380, height: 1, depthOrArrayLayers: 3} |
| */ |
| { |
| source: videoFrame11, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(50); }; |
| } catch {} |
| document.body.append(canvas1); |
| await gc(); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup56, []); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup18, new Uint32Array(3347), 1_272, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup58, new Uint32Array(4207), 104, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(869); |
| } catch {} |
| try { |
| commandEncoder80.insertDebugMarker('\u3b57'); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let textureView162 = texture170.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer115, 20); }; |
| } catch {} |
| try { |
| computePassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(5, buffer62, 0, 20); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 381, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture166, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder86.resolveQuerySet(querySet0, 363, 1, buffer7, 0); |
| } catch {} |
| let buffer127 = device0.createBuffer({size: 108, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder133 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup57, new Uint32Array(1003), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(7, buffer107, 200, 11); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer118, 'uint32', 4, 10); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(1, buffer65); |
| } catch {} |
| await gc(); |
| let buffer128 = device0.createBuffer({size: 56, usage: GPUBufferUsage.STORAGE}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1, 3); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer125, 0); }; |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| buffer115.unmap(); |
| } catch {} |
| let bindGroup95 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 2, resource: textureView80}, |
| {binding: 239, resource: {buffer: buffer22, size: 80}}, |
| {binding: 25, resource: {buffer: buffer25, size: 48}}, |
| ], |
| }); |
| let texture173 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| commandEncoder47.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 6}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder112.clearBuffer(buffer62); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer18, commandBuffer17]); |
| } catch {} |
| let veryExplicitBindGroupLayout31 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 0, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 2, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 3, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 14, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 18, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 49, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| {binding: 62, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: true }}, |
| { |
| binding: 92, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 211, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 222, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 234, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 416, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8sint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let textureView163 = texture123.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder36 = commandEncoder127.beginComputePass(); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer45, 0, 22); |
| } catch {} |
| let bindGroup96 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout21, |
| entries: [ |
| {binding: 4, resource: textureView87}, |
| {binding: 73, resource: {buffer: buffer46, offset: 0}}, |
| {binding: 0, resource: {buffer: buffer128, offset: 0}}, |
| {binding: 154, resource: textureView91}, |
| ], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer1, 0); }; |
| } catch {} |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let veryExplicitBindGroupLayout32 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let texture174 = device0.createTexture({ |
| size: {width: 2}, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder34.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer124, 'uint32', 4, 14); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(3, buffer95, 0); |
| } catch {} |
| try { |
| buffer96.unmap(); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise19; |
| } catch {} |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let commandBuffer19 = commandEncoder16.finish(); |
| let textureView164 = texture30.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder10.setPipeline(pipeline24); |
| } catch {} |
| let imageData18 = new ImageData(12, 20); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroupsIndirect(buffer23, 4); }; |
| } catch {} |
| try { |
| computePassEncoder33.end(); |
| } catch {} |
| try { |
| computePassEncoder28.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer55, 'uint16', 30, 6); |
| } catch {} |
| await gc(); |
| let buffer129 = device0.createBuffer({ |
| size: 362, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let textureView165 = texture38.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroups(2, 2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(0, buffer84, 32, 12); |
| } catch {} |
| let offscreenCanvas4 = new OffscreenCanvas(7, 289); |
| let commandEncoder136 = device0.createCommandEncoder({}); |
| let texture175 = device0.createTexture({ |
| size: [414, 1, 4], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder37 = commandEncoder97.beginComputePass(); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer124, 'uint32', 8, 29); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(3, bindGroup67, new Uint32Array(609), 199, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer4, 'uint32', 0, 1); |
| } catch {} |
| try { |
| renderBundleEncoder25.setVertexBuffer(6, buffer95, 36, 48); |
| } catch {} |
| try { |
| commandEncoder133.copyBufferToBuffer(buffer75, 4, buffer36, 4, 0); |
| } catch {} |
| let commandBuffer20 = commandEncoder29.finish(); |
| let textureView166 = texture116.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup11); |
| } catch {} |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder17.setVertexBuffer(0, buffer35, 48, 35); |
| } catch {} |
| try { |
| buffer115.unmap(); |
| } catch {} |
| try { |
| commandEncoder104.copyTextureToTexture({ |
| texture: texture44, |
| mipLevel: 1, |
| origin: {x: 71, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 65, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 43, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| computePassEncoder37.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(1, buffer26); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 8, new DataView(new ArrayBuffer(108416)), 284, 32); |
| } catch {} |
| let pipeline30 = await promise15; |
| let buffer130 = device0.createBuffer({size: 248, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup24, new Uint32Array(234), 84, 0); |
| } catch {} |
| try { |
| commandEncoder64.resolveQuerySet(querySet1, 200, 2, buffer99, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let computePassEncoder38 = commandEncoder101.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder9.end(); |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline24); |
| } catch {} |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'film', transfer: 'linear'} }); |
| try { |
| globalThis.someLabel = externalTexture11.label; |
| } catch {} |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup40, new Uint32Array(1823), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(5, buffer58); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer102, 'uint16', 32, 143); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(2, buffer3, 0); |
| } catch {} |
| let buffer131 = device0.createBuffer({ |
| size: 184, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder32); computePassEncoder32.dispatchWorkgroupsIndirect(buffer32, 20); }; |
| } catch {} |
| try { |
| computePassEncoder32.end(); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer4, 'uint16', 0, 0); |
| } catch {} |
| let imageData19 = new ImageData(32, 8); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| let texture176 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 51}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView167 = texture115.createView({mipLevelCount: 1, baseArrayLayer: 20, arrayLayerCount: 7}); |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer55, 'uint16', 18, 1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture142, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(102).fill(43), /* required buffer size: 102 */ |
| {offset: 102}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| try { |
| adapter1.label = '\uac77\u1d70'; |
| } catch {} |
| let veryExplicitBindGroupLayout33 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| {binding: 7, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 301, visibility: 0, buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }}, |
| { |
| binding: 362, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer107, 8, new Uint32Array(2303).map((_, i) => i * 9), 23, 0); |
| } catch {} |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup86, new Uint32Array(190), 13, 2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder30.dispatchWorkgroupsIndirect(buffer36, 4); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer35, 'uint16', 118, 54); |
| } catch {} |
| let imageData20 = new ImageData(32, 12); |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer124, 'uint16', 6, 4); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 44, new Float32Array(2833).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.589)), 362, 0); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let offscreenCanvas5 = new OffscreenCanvas(291, 55); |
| let buffer132 = device0.createBuffer({size: 84, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder142 = device0.createCommandEncoder({}); |
| let texture177 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1196}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup83, new Uint32Array(1498), 422, 2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer80, 'uint16', 8, 36); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer30, 12, new Float32Array(1927).map((_, i) => (i % 2 ? Math.sin : Math.cos)(i + 2.799)), 317, 8); |
| } catch {} |
| let gpuCanvasContext5 = offscreenCanvas5.getContext('webgpu'); |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| document.body.append(canvas0); |
| await gc(); |
| let texture178 = device0.createTexture({ |
| size: [345], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup30, new Uint32Array(1724), 151, 0); |
| } catch {} |
| let arrayBuffer13 = buffer61.getMappedRange(136, 4); |
| try { |
| await buffer112.mapAsync(GPUMapMode.READ, 0, 0); |
| } catch {} |
| let computePassEncoder39 = commandEncoder43.beginComputePass(); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup12, new Uint32Array(2726), 187, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer97); |
| } catch {} |
| let gpuCanvasContext6 = offscreenCanvas4.getContext('webgpu'); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let autogeneratedBindGroupLayout9 = pipeline26.getBindGroupLayout(0); |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| let externalTexture23 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder27.end(); |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup92, new Uint32Array(1711), 257, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer24, 'uint32', 20, 37); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer113, 4, new DataView(new ArrayBuffer(20876)), 208, 0); |
| } catch {} |
| let texture179 = device0.createTexture({size: {width: 414}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup94, []); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer84, 'uint32', 60, 19); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer132, 0, 8); |
| } catch {} |
| document.body.append(canvas0); |
| try { |
| computePassEncoder28.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup84); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(6, buffer23); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline24); |
| } catch {} |
| try { |
| buffer62.unmap(); |
| } catch {} |
| await gc(); |
| let bindGroup97 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 0, resource: {buffer: buffer22, size: 272}}, |
| {binding: 2, resource: textureView125}, |
| {binding: 38, resource: textureView85}, |
| ], |
| }); |
| let buffer133 = device0.createBuffer({size: 156, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let commandBuffer21 = commandEncoder53.finish(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer81, 192, 59); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(6, buffer62, 0, 78); |
| } catch {} |
| let textureView168 = texture21.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let externalTexture24 = device0.importExternalTexture({source: videoFrame17, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer38, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline30); |
| } catch {} |
| let commandEncoder144 = device0.createCommandEncoder(); |
| let texture180 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler20 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.16, |
| compare: 'never', |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup54); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToBuffer({ |
| texture: texture106, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 296 widthInBlocks: 37 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1600 */ |
| offset: 1600, |
| buffer: buffer46, |
| }, {width: 37, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer21, commandBuffer20]); |
| } catch {} |
| await gc(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| querySet0.destroy(); |
| } catch {} |
| try { |
| await buffer75.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder35.setBindGroup(0, bindGroup81, [0, 0]); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer60, 'uint32', 4, 0); |
| } catch {} |
| try { |
| commandEncoder80.clearBuffer(buffer5); |
| } catch {} |
| document.body.append(img3); |
| let buffer134 = device0.createBuffer({size: 216, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let texture181 = device0.createTexture({ |
| size: [414, 1, 21], |
| mipLevelCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder40 = commandEncoder118.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup33, new Uint32Array(428), 183, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer96, 'uint16', 32, 28); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(1, buffer58); |
| } catch {} |
| let commandEncoder146 = device0.createCommandEncoder(); |
| let texture182 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| }); |
| let externalTexture25 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup80, new Uint32Array(4468), 455, 0); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer102, 'uint16', 106, 3); |
| } catch {} |
| try { |
| commandEncoder129.copyBufferToBuffer(buffer127, 44, buffer25, 28, 8); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'}); |
| } catch {} |
| let buffer135 = device0.createBuffer({size: 251, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder30.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(3, buffer23, 8); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(2, bindGroup11, new Uint32Array(1734), 225, 0); |
| } catch {} |
| let arrayBuffer14 = buffer61.getMappedRange(144, 0); |
| try { |
| buffer110.unmap(); |
| } catch {} |
| let img6 = await imageWithData(10, 4, '#10101010', '#20202020'); |
| let commandEncoder147 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder31.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline24); |
| } catch {} |
| let veryExplicitBindGroupLayout34 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 1, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 14, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 117, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 242, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer136 = device0.createBuffer({size: 36, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder35.setBindGroup(1, bindGroup60); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup91, new Uint32Array(2551), 349, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline21); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let buffer137 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let texture183 = device0.createTexture({ |
| size: [1656, 1, 17], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView169 = texture8.createView({dimension: '3d'}); |
| try { |
| renderPassEncoder19.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer35, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup87, new Uint32Array(704), 353, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData21 = new ImageData(8, 12); |
| let bindGroup98 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 1, resource: textureView44}, |
| {binding: 3, resource: {buffer: buffer79}}, |
| {binding: 16, resource: textureView45}, |
| {binding: 2, resource: {buffer: buffer61}}, |
| {binding: 7, resource: textureView21}, |
| ], |
| }); |
| let commandBuffer22 = commandEncoder14.finish({}); |
| let textureView170 = texture183.createView({}); |
| let texture184 = device0.createTexture({ |
| size: {width: 4, height: 4, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder28.setBindGroup(2, bindGroup1, new Uint32Array(2678), 116, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup10, new Uint32Array(1516), 507, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| renderBundleEncoder2.setVertexBuffer(0, buffer6, 56, 3); |
| } catch {} |
| try { |
| commandEncoder84.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 70, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 312 */ |
| offset: 312, |
| buffer: buffer129, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img6); |
| let buffer138 = device0.createBuffer({size: 88, usage: GPUBufferUsage.COPY_DST}); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup81, new Uint32Array(1950), 106, 2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer36, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer4, 'uint32', 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 690, height: 1, depthOrArrayLayers: 43} |
| */ |
| { |
| source: offscreenCanvas4, |
| origin: { x: 0, y: 72 }, |
| flipY: true, |
| }, { |
| texture: texture135, |
| mipLevel: 2, |
| origin: {x: 109, y: 0, z: 6}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup99 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [ |
| {binding: 73, resource: {buffer: buffer46, offset: 0}}, |
| {binding: 154, resource: textureView103}, |
| {binding: 0, resource: {buffer: buffer100}}, |
| {binding: 4, resource: textureView156}, |
| ], |
| }); |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| let texture185 = device0.createTexture({ |
| size: {width: 2, height: 2, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView171 = texture75.createView({}); |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer38, 0, 6); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder109.copyBufferToBuffer(buffer59, 0, buffer87, 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.insertDebugMarker('\u{1fc8c}'); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| let renderPassEncoder21 = commandEncoder110.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView158, |
| clearValue: { r: -738.8, g: 563.5, b: -931.9, a: -482.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup85, [0, 0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToTexture({ |
| /* bytesInLastRow: 316 widthInBlocks: 79 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1412 */ |
| offset: 1412, |
| bytesPerRow: 11776, |
| rowsPerImage: 2904, |
| buffer: buffer85, |
| }, { |
| texture: texture129, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 79, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| let buffer139 = device0.createBuffer({size: 16, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let computePassEncoder41 = commandEncoder115.beginComputePass(); |
| try { |
| computePassEncoder41.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup84); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| try { |
| externalTexture15.label = '\u{1fcba}\uda2a\uffe6\u{1f793}\u{1f84e}\u052b\ua95b\u6654\uc0f6\ucd68'; |
| } catch {} |
| let texture186 = device0.createTexture({ |
| size: [1656, 1, 437], |
| mipLevelCount: 8, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16uint'], |
| }); |
| try { |
| computePassEncoder35.setBindGroup(3, bindGroup9, new Uint32Array(2038), 499, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer117, 4); }; |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer84, 'uint16', 18, 8); |
| } catch {} |
| try { |
| computePassEncoder37.end(); |
| } catch {} |
| let arrayBuffer15 = buffer61.getMappedRange(152, 0); |
| let bindGroup100 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 153, resource: {buffer: buffer15}}, |
| {binding: 116, resource: textureView2}, |
| {binding: 0, resource: textureView22}, |
| {binding: 49, resource: {buffer: buffer74, size: 48}}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 5, resource: externalTexture9}, |
| {binding: 3, resource: textureView0}, |
| {binding: 312, resource: sampler20}, |
| {binding: 159, resource: sampler13}, |
| {binding: 7, resource: {buffer: buffer61}}, |
| {binding: 59, resource: {buffer: buffer15}}, |
| {binding: 2, resource: externalTexture11}, |
| {binding: 308, resource: textureView73}, |
| {binding: 4, resource: {buffer: buffer116}}, |
| {binding: 17, resource: externalTexture25}, |
| {binding: 1, resource: {buffer: buffer131, size: 48}}, |
| {binding: 61, resource: textureView8}, |
| {binding: 109, resource: textureView94}, |
| {binding: 524, resource: textureView85}, |
| ], |
| }); |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup91); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer23, 8); }; |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer118, 0, 21); |
| } catch {} |
| try { |
| renderBundleEncoder1.setIndexBuffer(buffer129, 'uint16', 90, 56); |
| } catch {} |
| try { |
| buffer122.unmap(); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| let texture187 = device0.createTexture({ |
| size: [2], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup55); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer102, 'uint16', 14, 58); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline26); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline24); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer22]); |
| } catch {} |
| document.body.append(img6); |
| let computePassEncoder42 = commandEncoder112.beginComputePass(); |
| try { |
| computePassEncoder42.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderBundleEncoder17.setIndexBuffer(buffer4, 'uint32', 4, 0); |
| } catch {} |
| let pipeline31 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule4, entryPoint: 'compute3'}}); |
| try { |
| await promise22; |
| } catch {} |
| let buffer140 = device0.createBuffer({size: 100, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: false}); |
| let commandEncoder150 = device0.createCommandEncoder({}); |
| let textureView172 = texture183.createView({}); |
| let texture188 = device0.createTexture({ |
| size: [828, 1, 103], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| let sampler22 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.24, |
| compare: 'not-equal', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroupsIndirect(buffer137, 40); }; |
| } catch {} |
| try { |
| renderBundleEncoder29.setPipeline(pipeline30); |
| } catch {} |
| try { |
| buffer104.unmap(); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToTexture({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 114, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture124, |
| mipLevel: 0, |
| origin: {x: 98, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 51, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer87, 0, new Uint32Array(222).map((_, i) => i * 3), 89, 0); |
| } catch {} |
| let commandEncoder151 = device0.createCommandEncoder({}); |
| let texture189 = device0.createTexture({ |
| size: [1, 1, 146], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView173 = texture171.createView({baseArrayLayer: 3, arrayLayerCount: 9}); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup70, [0, 0]); |
| } catch {} |
| try { |
| computePassEncoder35.end(); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup58, new Uint32Array(914), 26, 0); |
| } catch {} |
| let arrayBuffer16 = buffer61.getMappedRange(160, 0); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer137, 76, new DataView(new ArrayBuffer(40836)), 1755, 0); |
| } catch {} |
| let bindGroup101 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout26, |
| entries: [ |
| {binding: 2, resource: textureView35}, |
| {binding: 239, resource: {buffer: buffer87}}, |
| {binding: 25, resource: {buffer: buffer46, offset: 0, size: 632}}, |
| ], |
| }); |
| let textureView174 = texture180.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup79); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(1, buffer26, 4, 6); |
| } catch {} |
| let commandBuffer23 = commandEncoder88.finish(); |
| let texture190 = device0.createTexture({ |
| size: {width: 414, height: 1, depthOrArrayLayers: 109}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder43 = commandEncoder103.beginComputePass(); |
| try { |
| computePassEncoder31.setBindGroup(3, bindGroup69, new Uint32Array(37), 8, 0); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer129, 124, new BigInt64Array(38234).map((_, i) => BigInt(i - 6)), 3501, 8); |
| } catch {} |
| let bindGroup102 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout34, |
| entries: [ |
| {binding: 117, resource: textureView98}, |
| {binding: 242, resource: textureView76}, |
| {binding: 1, resource: {buffer: buffer46}}, |
| {binding: 21, resource: textureView23}, |
| {binding: 14, resource: textureView93}, |
| ], |
| }); |
| let texture191 = device0.createTexture({ |
| size: {width: 2760, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder44 = commandEncoder141.beginComputePass(); |
| try { |
| computePassEncoder36.end(); |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(1, buffer97, 0); |
| } catch {} |
| let veryExplicitBindGroupLayout35 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 16, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 65, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let buffer141 = device0.createBuffer({size: 40, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let commandEncoder152 = device0.createCommandEncoder({label: '\ue907\u{1f6d6}\u{1ffcb}\u00f0\u1ecc\u2679\u09c7\u0479\u8c0d'}); |
| let texture192 = device0.createTexture({size: {width: 256}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder43.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer76, 0); |
| } catch {} |
| try { |
| commandEncoder40.clearBuffer(buffer117); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let offscreenCanvas6 = new OffscreenCanvas(191, 96); |
| let bindGroup103 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 153, resource: {buffer: buffer46, offset: 256}}, |
| {binding: 7, resource: {buffer: buffer15, size: 236}}, |
| {binding: 0, resource: textureView160}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 312, resource: sampler18}, |
| {binding: 1, resource: {buffer: buffer84}}, |
| {binding: 3, resource: textureView28}, |
| {binding: 59, resource: {buffer: buffer116}}, |
| {binding: 308, resource: textureView130}, |
| {binding: 2, resource: externalTexture15}, |
| {binding: 17, resource: externalTexture7}, |
| {binding: 159, resource: sampler1}, |
| {binding: 524, resource: textureView35}, |
| {binding: 5, resource: externalTexture2}, |
| {binding: 49, resource: {buffer: buffer36}}, |
| {binding: 109, resource: textureView159}, |
| {binding: 61, resource: textureView9}, |
| {binding: 4, resource: {buffer: buffer81}}, |
| {binding: 116, resource: textureView4}, |
| ], |
| }); |
| let texture193 = device0.createTexture({size: [828, 1, 120], mipLevelCount: 4, format: 'rgba16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer117, 76); }; |
| } catch {} |
| try { |
| renderPassEncoder21.beginOcclusionQuery(457); |
| } catch {} |
| try { |
| renderBundleEncoder24.setVertexBuffer(7, buffer111); |
| } catch {} |
| let gpuCanvasContext7 = offscreenCanvas6.getContext('webgpu'); |
| let textureView175 = texture132.createView({aspect: 'all', baseMipLevel: 0}); |
| let computePassEncoder45 = commandEncoder130.beginComputePass(); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup85, [0, 0]); |
| } catch {} |
| try { |
| computePassEncoder43.setBindGroup(0, bindGroup83, new Uint32Array(918), 118, 2); |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer118, 'uint16', 0, 9); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(6, buffer26, 0, 16); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| try { |
| adapter1.label = '\u{1f69b}\u0cd4\u0615\u0925\u0e27\u{1f757}'; |
| } catch {} |
| let bindGroup104 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout27, |
| entries: [ |
| {binding: 25, resource: {buffer: buffer128}}, |
| {binding: 239, resource: {buffer: buffer132}}, |
| {binding: 2, resource: textureView80}, |
| ], |
| }); |
| let texture194 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 1}, |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer35, 'uint16', 70, 127); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup10, new Uint32Array(2122), 1_281, 0); |
| } catch {} |
| try { |
| commandEncoder95.resolveQuerySet(querySet2, 0, 0, buffer7, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| toneMapping: {mode: 'extended'}, |
| }); |
| } catch {} |
| let buffer142 = device0.createBuffer({size: 288, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let texture195 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView176 = texture135.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 12}); |
| try { |
| renderPassEncoder21.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline24); |
| } catch {} |
| let arrayBuffer17 = buffer61.getMappedRange(168, 0); |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder12.insertDebugMarker('\u{1f800}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer95, 12, new Float64Array(4588).map((_, i) => (i % 2 ? Math.acos : Math.asin)(i/4586)), 2069, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer143 = device0.createBuffer({ |
| size: 32, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder41.setBindGroup(1, bindGroup68, new Uint32Array(799), 178, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.beginOcclusionQuery(297); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 63}, |
| aspect: 'all', |
| }, new Uint8Array(100).fill(241), /* required buffer size: 100 */ |
| {offset: 100, bytesPerRow: 288}, {width: 58, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView177 = texture21.createView({mipLevelCount: 1}); |
| let sampler23 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder40.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer109, 'uint16', 0, 74); |
| } catch {} |
| try { |
| commandEncoder17.resolveQuerySet(querySet1, 175, 107, buffer85, 256); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(1, bindGroup78); |
| } catch {} |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup46, new Uint32Array(864), 369, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer109, 'uint32', 60, 88); |
| } catch {} |
| let bindGroup105 = device0.createBindGroup({layout: recycledExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let buffer144 = device0.createBuffer({size: 44, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer58, 0, 28); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup104); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| toneMapping: {mode: 'standard'}, |
| }); |
| } catch {} |
| document.body.prepend(img6); |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpteSt4281', transfer: 'gamma28curve'} }); |
| let bindGroup106 = device0.createBindGroup({layout: veryExplicitBindGroupLayout3, entries: [{binding: 93, resource: textureView5}]}); |
| let texture196 = device0.createTexture({ |
| size: {width: 345}, |
| dimension: '1d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder20.setVertexBuffer(2, buffer23, 44, 9); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer107, 'uint32', 8, 34); |
| } catch {} |
| try { |
| renderBundleEncoder11.insertDebugMarker('\u{1fb64}'); |
| } catch {} |
| let pipeline32 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule6}}); |
| let bindGroup107 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 312, resource: sampler20}, |
| {binding: 3, resource: textureView75}, |
| {binding: 49, resource: {buffer: buffer111}}, |
| {binding: 61, resource: textureView90}, |
| {binding: 17, resource: externalTexture5}, |
| {binding: 5, resource: externalTexture4}, |
| {binding: 4, resource: {buffer: buffer116}}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 153, resource: {buffer: buffer15, offset: 0}}, |
| {binding: 0, resource: textureView22}, |
| {binding: 524, resource: textureView80}, |
| {binding: 7, resource: {buffer: buffer116}}, |
| {binding: 116, resource: textureView4}, |
| {binding: 308, resource: textureView73}, |
| {binding: 109, resource: textureView165}, |
| {binding: 2, resource: externalTexture23}, |
| {binding: 1, resource: {buffer: buffer130}}, |
| {binding: 159, resource: sampler1}, |
| {binding: 59, resource: {buffer: buffer15}}, |
| ], |
| }); |
| let buffer145 = device0.createBuffer({size: 260, usage: GPUBufferUsage.UNIFORM}); |
| let commandEncoder153 = device0.createCommandEncoder(); |
| let texture197 = device0.createTexture({ |
| size: {width: 1656, height: 1, depthOrArrayLayers: 133}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView178 = texture178.createView({dimension: '1d', aspect: 'all', baseArrayLayer: 0}); |
| try { |
| computePassEncoder39.setBindGroup(0, bindGroup86, [0, 0]); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer58, 80, 73); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer96, 'uint32', 12, 7); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(0, buffer110, 0); |
| } catch {} |
| let arrayBuffer18 = buffer75.getMappedRange(0, 4); |
| try { |
| device0.queue.writeBuffer(buffer63, 24, new Uint32Array(2661).map((_, i) => i * 1), 615, 0); |
| } catch {} |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let texture198 = device0.createTexture({ |
| size: {width: 207, height: 1, depthOrArrayLayers: 47}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView179 = texture120.createView({baseArrayLayer: 0}); |
| let computePassEncoder46 = commandEncoder129.beginComputePass(); |
| try { |
| renderBundleEncoder21.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(2, bindGroup19, new Uint32Array(2082), 114, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline30); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'bt709', transfer: 'logSqrt'} }); |
| let commandBuffer24 = commandEncoder118.finish(); |
| let sampler24 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'nearest', lodMaxClamp: 98.88}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer118, 'uint32', 4, 5); |
| } catch {} |
| let texture199 = device0.createTexture({ |
| size: {width: 690, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroupsIndirect(buffer143, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup104, new Uint32Array(4064), 1_105, 0); |
| } catch {} |
| try { |
| commandEncoder94.copyBufferToBuffer(buffer86, 228, buffer47, 4, 4); |
| } catch {} |
| try { |
| computePassEncoder24.insertDebugMarker('\u82bf'); |
| } catch {} |
| let bindGroup108 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 93, resource: textureView1}]}); |
| let buffer146 = device0.createBuffer({ |
| size: 8, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let textureView180 = texture64.createView({label: '\u4f03', format: 'rgba16sint', baseArrayLayer: 0}); |
| let renderPassEncoder22 = commandEncoder100.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView158, |
| clearValue: { r: -196.3, g: -747.0, b: 746.0, a: -233.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup55); |
| } catch {} |
| try { |
| computePassEncoder31.setBindGroup(3, bindGroup77, new Uint32Array(3187), 391, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer133, 60); }; |
| } catch {} |
| try { |
| computePassEncoder46.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(0, buffer97, 676); |
| } catch {} |
| try { |
| if (!arrayBuffer17.detached) { new Uint8Array(arrayBuffer17).fill(67); }; |
| } catch {} |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| let textureView181 = texture65.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup95, new Uint32Array(228), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer36, 'uint32', 0, 9); |
| } catch {} |
| try { |
| renderBundleEncoder1.setVertexBuffer(0, buffer114, 0); |
| } catch {} |
| let imageData22 = new ImageData(28, 44); |
| let videoFrame28 = new VideoFrame(offscreenCanvas2, {timestamp: 0}); |
| let bindGroup109 = device0.createBindGroup({layout: autogeneratedBindGroupLayout4, entries: [{binding: 93, resource: textureView5}]}); |
| let texture200 = device0.createTexture({ |
| size: [4, 4, 136], |
| dimension: '3d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup94, new Uint32Array(56), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer102, 'uint16', 42, 22); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer3, 264, 18); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer38, 'uint16', 14, 1); |
| } catch {} |
| try { |
| await shaderModule8.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder137.resolveQuerySet(querySet2, 0, 0, buffer122, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroupsIndirect(buffer36, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer96, 'uint16', 20, 14); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(4, buffer118, 12, 26); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup44); |
| } catch {} |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup87, new Uint32Array(768), 136, 0); |
| } catch {} |
| let buffer147 = device0.createBuffer({ |
| size: 284, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder158 = device0.createCommandEncoder(); |
| let sampler25 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 71.71, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup32); |
| } catch {} |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup16, new Uint32Array(655), 2, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder39); computePassEncoder39.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| await shaderModule4.getCompilationInfo(); |
| } catch {} |
| try { |
| buffer101.unmap(); |
| } catch {} |
| try { |
| commandEncoder143.copyBufferToBuffer(buffer81, 264, buffer143, 0, 4); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer24]); |
| } catch {} |
| let veryExplicitBindGroupLayout36 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 14, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let textureView182 = texture85.createView({arrayLayerCount: 1}); |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup71); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer136, 'uint16', 6, 7); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(5, buffer58, 28); |
| } catch {} |
| let arrayBuffer19 = buffer61.getMappedRange(176, 0); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture124, |
| mipLevel: 1, |
| origin: {x: 236, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(118_126).fill(23), /* required buffer size: 118_126 */ |
| {offset: 19, bytesPerRow: 1193, rowsPerImage: 11}, {width: 148, height: 0, depthOrArrayLayers: 10}); |
| } catch {} |
| let textureView183 = texture68.createView({dimension: '1d', baseMipLevel: 0}); |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer84, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(1, bindGroup109); |
| } catch {} |
| try { |
| renderBundleEncoder22.setPipeline(pipeline30); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let arrayBuffer20 = buffer75.getMappedRange(8, 0); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer148 = device0.createBuffer({size: 152, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| let textureView184 = texture142.createView({dimension: '2d-array'}); |
| let texture201 = device0.createTexture({ |
| size: [2, 2, 1], |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder17.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer148, 'uint32', 20, 22); |
| } catch {} |
| let bindGroup110 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 2, resource: externalTexture25}, |
| {binding: 116, resource: textureView4}, |
| {binding: 3, resource: textureView0}, |
| {binding: 10, resource: {buffer: buffer46}}, |
| {binding: 0, resource: textureView32}, |
| {binding: 59, resource: {buffer: buffer116}}, |
| {binding: 109, resource: textureView94}, |
| {binding: 61, resource: textureView90}, |
| {binding: 4, resource: {buffer: buffer15, size: 1088}}, |
| {binding: 49, resource: {buffer: buffer142}}, |
| {binding: 1, resource: {buffer: buffer130, offset: 0}}, |
| {binding: 308, resource: textureView16}, |
| {binding: 524, resource: textureView80}, |
| {binding: 312, resource: sampler18}, |
| {binding: 159, resource: sampler12}, |
| {binding: 5, resource: externalTexture21}, |
| {binding: 17, resource: externalTexture10}, |
| {binding: 7, resource: {buffer: buffer74, size: 184}}, |
| {binding: 153, resource: {buffer: buffer46}}, |
| ], |
| }); |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let commandBuffer25 = commandEncoder97.finish(); |
| let texture202 = device0.createTexture({ |
| size: [345, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder2.setVertexBuffer(5, buffer6, 0, 22); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer23, commandBuffer25]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 12, new DataView(new ArrayBuffer(15688)), 57, 4); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame16.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| await gc(); |
| |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0(), window1() ]; |
| log('promises created'); |
| let results = await Promise.allSettled(promises); |
| for (let result of results) { |
| if (result.status === 'rejected') { throw result.reason; } |
| } |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| console.debug('Pass'); |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
| Pass |
